ExanorOS

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for behavioral disclosure. 'Append' implies modification, but it does not specify where content is added (end), whether existing content is preserved, permission requirements, or any potential side effects. Critical details are missing for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

While the description is a single short sentence, it is under-specified to the point of being unhelpful. It does not front-load essential details like which Google Docs can be appended to or any constraints. Brevity here is a deficiency, not a virtue.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with two simple parameters and no output schema, the description still leaves major gaps: it does not clarify what fileId refers to, how append behaves on large docs, whether it is idempotent, or what the return value indicates. The description is insufficient for an agent to invoke the tool correctly without additional assumptions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not elaborate on the parameters. The names 'fileId' and 'content' offer minimal hints, but the description fails to explain how to obtain a fileId or how content should be formatted. The description adds no semantic value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Append content') and resource ('Google Doc'). It distinguishes itself from sibling tools like create_doc (which creates new docs) and read_drive_file (which reads), making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. It does not mention that this is for adding content to existing docs, nor does it point to create_doc for new docs. The agent is left to infer usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only says 'Add rows,' offering no details about whether the operation is append-only, requires specific permissions, handles optional sheetName, or what happens on duplicate or mismatched values. The behavior is minimally clear but lacks critical context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no unnecessary words. It is concise and easy to parse, though it sacrifices completeness. From a pure structure standpoint, it is efficient, but the brevity leaves out essential details.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has three parameters, no annotations, and no output schema, so the description needs to compensate. It fails to explain the parameters, any prerequisites, or the result of the operation. The description is too sparse to be considered complete for an AI agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any parameters. It gives no hints about what fileId, values, or sheetName mean or how they should be used. The word 'rows' vaguely maps to 'values' but does not clarify the array-of-arrays structure or the role of sheetName.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (Add rows) and the specific resource (Excel file in OneDrive), making the tool's purpose immediately understandable. It also distinguishes from the sibling tool append_to_sheet by specifying the file type and storage location, which is likely a different spreadsheet service (e.g., Google Sheets).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives like append_to_sheet or append_to_doc. The description only states what it does, leaving the agent without explicit context for selection among similar append tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Add rows' without describing details such as whether rows are appended to the end, whether the sheet must exist beforehand, or any authentication requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that is front-loaded with the core action. It is efficient, though the lack of additional detail makes it borderline under-specified.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and minimal schema metadata, the description is too sparse to be contextually complete. It omits information about return values, error conditions, and behavioral nuances that would help an agent use the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, and the description does not explain the parameters. 'Rows' loosely maps to the values array, but fileId and sheetName are not mentioned, leaving the agent without critical guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Add' and a specific resource 'rows to a Google Sheet', clearly distinguishing this tool from siblings like append_to_doc and append_to_excel. It unambiguously communicates what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly states the target resource (a Google Sheet), giving implicit context on when to use it vs. alternatives for other file types. However, it does not explicitly mention alternative tools or list exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action ('Cancel a Calendly booking') without revealing that cancellation is likely irreversible, may require specific permissions, or may trigger notifications to the invitee. This is a significant transparency gap for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with every word earning its place. It avoids unnecessary detail and is easily scannable by an agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the tool's simplicity, the description is incomplete for safe invocation. It lacks information about the success/failure response, preconditions (e.g., booking must exist, ownership), side effects, and the purpose of the optional reason field. With no output schema and no annotations, the agent is left guessing about the tool's full behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description adds value only for 'uuid' (identifies the booking). It says nothing about 'reason', its optionality, or its format, leaving the agent without enough information to correctly fill the parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb ('Cancel'), resource ('Calendly booking'), and method ('by UUID'), which distinguishes it from sibling tools like delete_calendar_event that target different calendar systems. The name and description are unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is used when a Calendly booking UUID is available, but it provides no explicit guidance on alternatives, prerequisites, or when not to use it. For instance, it doesn't mention needing to obtain the UUID first via get_calendly_links.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full responsibility. It says 'synthesized catch-up' but does not disclose whether the tool is read-only, what it does with messages (e.g., marks as read), or what the output structure is. This is a significant gap for an aggregator that might have side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences: the first states what the tool does, the second gives usage triggers. No filler or repetition, and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a zero-parameter tool: it states the aggregated sources and gives example queries. However, it does not specify what data from each source is included (e.g., all emails, unread only, specific Slack channels) or whether any action is taken beyond display. This leaves an agent to infer scope.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so per the rubric the baseline is 4. The description does not need to explain parameter syntax, and the empty schema already fully documents the absence of parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool produces a synthesized catch-up across inbox, calendar, and Slack, which is a specific resource scope. It distinguishes from single-source siblings like get_inbox or get_calendar, though the verb 'catch-up' is a bit colloquial.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit use cases: 'what did I miss' and 'what needs my attention'. It clearly implies when to use the tool, but does not name alternatives or exclusions, so the guideline is clear but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explicitly state that this is a read-only operation, what results look like, or whether it modifies any data. The phrase 'check availability' implies read-only but is not explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise, with two short sentences. The purpose is front-loaded and the usage guideline is directly relevant. No unnecessary words are present.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no annotations, no output schema, and incomplete parameter coverage, the description is too brief. It does not explain return values, how to interpret availability results, or how duration affects the check. The presence of similar tools like check_freebusy further highlights the lack of distinguishing details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It mentions 'date' as the target date but does not explain the 'duration' parameter or provide format expectations. This is insufficient for two parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function with a specific verb ('Check'), resource ('your calendar availability'), and scope ('for a date'). The added instruction 'ALWAYS call before creating events' reinforces its purpose and distinguishes it as a prerequisite step for event creation tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The instruction to 'ALWAYS call before creating events' provides explicit context for when to use this tool. However, it does not mention alternatives or any exclusions, so it lacks a full 'when-not-to-use' clause.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full burden of disclosing behavior, but it only states the core action. It does not specify whether the operation is read-only, what the response looks like, how multiple emails are handled, or any rate limits or permissions. The description adds minimal behavioral context beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence with no redundancy or irrelevant details. It is efficiently front-loaded with the core purpose, though it is perhaps too sparse, but for conciseness it earns a high score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with two parameters and no output schema, but the description provides only the bare action. It does not explain what 'free/busy' means in terms of return value, how to interpret results, or any edge cases. For a tool with no annotations and no output schema, this is insufficient context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not elaborate on the parameters 'emails' or 'date'. It fails to clarify the format of emails (e.g., CSV list) or the expected date format, leaving the agent with no additional meaning beyond type strings.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Check free/busy for other people on a date' clearly states the action and resource: checking availability of other people's calendars for a specific date. It uses a specific verb phrase and distinguishes from own-availability tools by saying 'other people,' but it does not explicitly differentiate from similar siblings like check_availability.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No usage guidelines are provided. The description does not mention when to use this tool versus alternatives such as check_availability or search_calendar, nor does it state any prerequisites or context for use. There is no 'when to use' guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden for behavioral disclosure. It implies a read-only check but does not state return format, error behavior for invalid envelope IDs, or what 'signed' means (e.g., all signers complete). This is insufficient for a tool without annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple status-check tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the tool's simplicity, the lack of annotations, output schema, and usage guidance leaves gaps. The description does not indicate what the tool returns (e.g., boolean, status object) or how the result should be interpreted, making it incomplete for an agent to invoke and act on reliably.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, and the description does not explain the envelopeId parameter beyond its name. While the parameter name is self-explanatory, the description adds no semantic value such as where to find the ID or what format it should take.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: checking whether a DocuSign document has been signed. It uses a specific verb and resource, and it is distinct from sending or voiding signatures, though it does not explicitly differentiate from the related get_docusign sibling.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as get_docusign, send_for_signature, or void_envelope. The description lacks any context about use cases, prerequisites, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses a key side effect: sending a welcome email. However, with no annotations, it does not cover other important behaviors such as prerequisites, idempotency, or error handling for duplicate accounts, leaving gaps for an AI agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one sentence, front-loaded with the purpose, and contains no irrelevant information. It is concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has 3 parameters including an enum, no output schema, and no annotations. The description covers only the primary action and side effect, omitting details about return values, duplicate handling, or post-creation behavior, making it incomplete for autonomous use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, and the description does not explain the meaning of parameters. It implies name and email are needed, but the 'plan' parameter and its enum options are not described, so the agent lacks essential guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action: create a new ExanorOS account and send a welcome email. This verb+resource combination effectively distinguishes it from sibling tools like create_contact or create_doc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool (creating an ExanorOS account). While it does not explicitly mention alternatives or exclusions, the tool's unique resource (ExanorOS account) makes the usage context obvious given the sibling list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the action 'Create a Google Calendar event' without mentioning side effects, required permissions, calendar selection, or post-creation behavior. This leaves the agent unaware of critical behavioral details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no extra words, making it concise. However, it is under-specified; it lacks essential details about the parameter and usage, so it is not appropriately sized for a tool that likely depends on a natural language instruction. It is lean but at the expense of informativeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, and a single undocumented parameter, the description is far from complete. It does not explain what the instruction should include, how the event is created, or what the agent should expect in return. This is inadequate for a tool with a flexible input parameter, leaving too much ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has a single 'instruction' parameter with no description, and schema description coverage is 0%. The tool description does not explain what 'instruction' should contain or how it is processed, so the agent is left guessing about the required input format. The description fails to compensate for the lack of schema detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a Google Calendar event with a specific verb and resource, distinguishing it from Outlook event creation. However, it doesn't explicitly differentiate from create_recurring_event or other calendar-related tools, so it's not fully distinguished among siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers no guidance on when to use this tool versus alternatives like create_recurring_event, create_outlook_event, or update_calendar_event. It does not mention any exclusions, prerequisites, or recommended contexts, so the agent has no basis for selecting this tool over others.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, authorization needs, or handling of duplicates or errors.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence that is front-loaded. It is not bloated, though it sacrifices informativeness for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity, the description is minimal but incomplete. It does not mention return values (no output schema), integration specifics, or criteria for selecting this over sibling contact-creation tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description adds no meaning beyond the schema's parameter names and types. It does not clarify format, constraints, or optionality of fields like email or phone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a new Google contact, using a specific verb and resource. It differentiates from siblings like create_outlook_contact and hubspot_create_contact by explicitly naming Google.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as create_outlook_contact or hubspot_create_contact. The description does not mention any exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden. It only states the action of creating a doc, but does not disclose side effects, return values, or required permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single terse sentence with no wasted words, but it is under-specified for a tool with two parameters, missing essential context while being too brief to be considered appropriately sized.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations, output schema, and parameter descriptions, the description is insufficient for an agent to confidently invoke the tool. It does not explain the behavior or output of the operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain the roles of 'name' or 'content' or that only 'name' is required. The agent must infer everything from parameter names alone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Create' and specifies the resource 'Google Doc', which clearly distinguishes it from siblings like create_sheet and append_to_doc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like append_to_doc or create_sheet. There is no mention of prerequisites, scenarios, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action and omits important details like permissions required, whether an existing file is overwritten, or the return value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that immediately communicates the tool's purpose with no unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple, but the description lacks context about where in OneDrive the file is created, what the function returns, and error behavior. This is insufficient for an agent to invoke it reliably.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has a single 'name' parameter with no description, and the description only implies it is the filename. It does not clarify if an extension is needed, whether a path can be specified, or any naming constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (create) and resource (new Excel file in OneDrive), which distinguishes it from sibling tools like create_doc and create_sheet. However, it could be more explicit about the type of Excel file (e.g., empty workbook).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as create_sheet or append_to_excel. It gives no context on preferred use cases or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action itself. It does not mention required fields, duplicate handling, permissions, or any side effects, leaving the agent without important context for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, succinct sentence with no extraneous information. It is front-loaded and easily parsed, earning full marks for conciseness even though it is minimal.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and a minimal description, the tool definition is incomplete for an agent to make a confident decision. It lacks usage context, parameter details, and behavioral caveats, making it only barely sufficient for a very simple tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has zero description coverage, and the description does not elaborate on any of the four parameters. Although parameter names like 'email' and 'company' are somewhat self-explanatory, the tool definition fails to provide any semantic detail or format expectations, so it does not compensate for the schema gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly specifies the action ('Create') and the resource ('new Outlook contact'), and the 'Outlook' qualifier distinguishes it from generic contact tools like create_contact or hubspot_create_contact. It is unambiguous and immediately understandable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as create_contact, lookup_outlook_contact, or update_contact. There is no mention of prerequisites, exclusions, or context that would help an agent choose this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits on its own. It only states the basic creation action and does not mention required parameters, return values, side effects like sending invitations, whether it creates Teams meetings, or any permission requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with front-loaded information and no redundant wording. It is appropriately concise for stating the core purpose, though it could benefit from more structure to guide usage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 5 parameters, 3 required, no annotations, and no output schema, this description is severely incomplete. It lacks any information about event creation behavior, return value, time formats, or side effects, making it insufficient for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 5 parameters with 0% description coverage, and the description adds no parameter information. It does not explain the format or meaning of start/end, the attendees array, or the teams_meeting boolean, leaving the agent without critical details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('new Outlook Calendar event'), making the tool's purpose obvious. However, it does not explicitly distinguish this tool from siblings like create_calendar_event or create_recurring_event, so it misses the top score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives, such as create_calendar_event or create_recurring_event. There are no usage contexts, prerequisites, or exclusions, leaving the agent to infer appropriate usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of disclosing behavioral aspects. It only states the action 'create' without detailing side effects, required permissions, recurrence rules format, or expected output. This is a significant gap for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no wasted words. However, given the tool's complexity (6 parameters), it is under-specified and lacks essential context. It is concise but not effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has 6 parameters, no annotations, and no output schema. The description provides only a high-level action, leaving the agent without critical details about how to construct a valid invocation, what recurrence means, or what happens upon success/failure.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not mention any of the six parameters (end, start, summary, attendees, recurrence, instruction). The agent receives no help in understanding parameter formats, constraints, or required vs optional fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and the specific resource ('a recurring Google Calendar event'). This distinguishes it from sibling tools like 'create_calendar_event' which likely handles non-recurring events.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as 'create_calendar_event' or 'update_calendar_event'. There is no mention of scenarios or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden for behavioral disclosure. It conveys that this is a create/mutation operation, but it omits any context about permissions, name conflicts, what happens to existing sheets, or the return value/response format. This is minimal transparency for a tool with side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence, which earns it points for conciseness. However, it is under-specified given the tool's 3 parameters and the absence of other documentation. While not as sparse as a single word, it does not cover necessary details, making it only minimally appropriate in size.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is one sentence and incomplete in context. There is no output schema, no annotations, and no parameter descriptions in the schema. The tool involves 3 parameters, yet the description says nothing about how they are used, what the result is, or any prerequisites. This is completely inadequate for an agent to use the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 3 parameters (name, values, sheetName) with 0% description coverage. The description 'Create a new Google Sheet.' provides no additional meaning for these parameters—it does not explain that 'name' is likely the sheet file name, 'values' is initial data, or 'sheetName' is the inner tab. The description entirely fails to compensate for the schema's lack of documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Create a new Google Sheet.' clearly states the verb and resource, making the basic action unmistakable. However, it does not differentiate from sibling tools like create_excel or append_to_sheet, so it lacks the distinguishing context needed for an agent to confidently select it among similar tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios where this is preferred or mention any exclusions. With numerous sibling tools for creating documents, spreadsheets, or appending data, the lack of usage context is a significant gap.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only says 'Delete', which implies a destructive action, but does not state whether deletion is permanent, requires special permissions, or has any side effects. For a mutation tool, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence with no wasted words. It is front-loaded and immediately states the action. While it could include more detail, it is concise and well-structured for its minimal content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple delete operation with one parameter and no annotations or output schema, the description is incomplete. It does not explain the effect of deletion, error conditions, or how to find the eventId. The tool is under-specified for an agent to use reliably.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage for the eventId parameter. The description does not mention eventId at all or explain how to identify the event to delete. The description adds no value beyond the bare schema, leaving the sole parameter completely unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Delete') and the resource ('a Google Calendar event'), which distinguishes it from sibling tools like delete_outlook_event. It is specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives. It does not mention when deletion is appropriate, prerequisites like event ownership, or how to obtain the eventId. Siblings like update_calendar_event exist but no exclusions are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full burden of behavioral disclosure. It does not mention whether deletion is permanent, requires permissions, or notifies attendees, leaving key behavioral traits undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no unnecessary words, making it highly concise and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is too sparse. It does not specify return values, error scenarios, or the impact of deletion, leaving the agent without enough context for reliable operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain the eventId parameter at all. The agent receives no information about what the value represents, its format, or where to obtain it, so the description fails to compensate for the lack of schema documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Delete') and the resource ('Outlook Calendar event'), which is specific and distinguishes it from sibling tools like create_outlook_event or delete_calendar_event.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as delete_calendar_event. The description gives no context about prerequisites or circumstances for deletion.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and parameter, but does not disclose whether the reminder is deleted or merely marked as dismissed, whether the action is reversible, or any permissions required. This is a significant gap for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The single sentence is concise and front-loaded, earning its place without any fluff. However, it is also terse and could include more context without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity (one string param, no output schema), the description is minimal. However, it fails to explain the consequences of the action or how to retrieve the reminder ID from get_reminders, making it incomplete for an agent to use confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has one property 'id' with no description, and the schema description coverage is 0%. The description only repeats 'by ID' without explaining what kind of ID is expected or how to obtain it. This adds little value over the schema itself.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (dismiss), the resource (reminder), and the method (by ID). It is distinct from sibling tools like get_reminders and set_reminder, which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention that get_reminders can be used to obtain the reminder ID, or that set_reminder might be used to modify reminders, leaving the agent without context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It lists the actions but does not disclose potential side effects (e.g., trash may be irreversible, add_label requires a labelName), permissions needed, or reversibility. For a mutation tool, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no redundant words. It efficiently communicates the core scope and is front-loaded with the key information. It earns a high score for conciseness despite omitting details, which is penalized elsewhere.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool that mutates email state, this description is too sparse. It lacks prerequisites (e.g., messageId from a prior search), the labelName requirement for add_label, and any behavioral expectations. There is no output schema, and annotations are absent, so the description is not complete enough for a simple but mutable tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not compensate. It never mentions messageId or labelName, nor does it specify that add_label requires labelName. The action enum values are the only hints, but parameter semantics are entirely delegated to the schema, which is insufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function with a specific verb ('Mark') and a specific resource ('Gmail email'), enumerating all supported actions (read/unread, archive, trash, add_label). This distinguishes it from siblings like send_email, forward_email, and outlook_email_action, which have different purposes. The verb 'Mark' is slightly imprecise for archive/trash/add_label, but the overall intent is unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: when you want to modify a Gmail email's state. However, it provides no explicit guidance on when to use this tool versus alternatives, such as outlook_email_action for Outlook, or search_email first to obtain a messageId. No exclusions or prerequisites are mentioned, so usage context is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action and does not mention return format, whether it returns content or metadata, matching behavior (exact vs fuzzy), or error handling when no file is found. This is a significant gap for an agent to understand expectations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that front-loads the verb 'Find' and directly states the search criterion. It contains no fluff and is appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the tool is simple, the description leaves critical information unstated: what is actually returned (file content, path, or reference), what happens if no match exists, and how exact the topic match must be. With no annotations or output schema, this brevity makes the tool insufficiently defined for confident invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has a single required 'topic' string with no description. The description adds 'by topic name', which clarifies that the parameter is the topic's name, but it does not explain accepted formats, whether search is case-sensitive, or any other parameter nuances. Given the 0% schema description coverage, the description should compensate more.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: finding a knowledge file by topic name. It uses a specific verb and resource, and it distinguishes itself from siblings like get_knowledge_index (which likely lists all knowledges) and save_to_knowledge (which writes).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, such as get_knowledge_index for browsing or search tools for full-text search. The description does not mention any exclusions or preferred contexts, so the agent is left without usage direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of behavioral disclosure. It states that it returns ratings, reviews, features, and booking links, but does not explicitly confirm it's read-only or mention any limitations (e.g., that booking links are just links, not actual reservations). This gives moderate transparency but leaves some gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that states the action and key outputs with no wasted words. It is concise and immediately understandable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 7 parameters, no annotations, and no output schema, the description is too sparse for an agent to fully understand how to invoke the tool correctly. It lacks guidance on required vs optional parameters, what 'covers' means, how to format date/time, and the structure of the returned data. The mention of outputs helps but the overall context is incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 14% (only 'price' is described), and the description does not compensate. It does not explain any of the seven parameters, including potentially ambiguous ones like 'covers' or how 'limit' works. The description adds minimal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Search' with a clear resource 'restaurants' and identifies the data source 'Google Places'. It also lists concrete outputs (ratings, reviews, features, booking links), which differentiates it from other search tools like search_drive or search_email.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is for restaurant discovery but does not explicitly state when to use it over alternatives or when not to use it. No exclusions or alternative tool references are provided, leaving the usage context implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of disclosure, but it only restates the action of forwarding. It does not explain side effects (e.g., creating a sent copy, modifying the original), authentication requirements, or behavior with attachments. This is a significant gap for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear, and front-loaded sentence with zero filler words. It is concise and easy to parse, though it sacrifices valuable information for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is highly incomplete given the tool's three parameters and lack of output schema. It does not explain expected return values, side effects, or when this tool is appropriate, leaving critical context missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, and the description provides no parameter details. It does not explain the purpose of 'to', 'note', or 'messageId', leaving the agent to infer everything from the raw schema field names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Forward' and the resource 'a Gmail email', indicating the tool's purpose for forwarding Gmail messages. It distinguishes from sibling forward_outlook_email by specifying the email provider, though it could be more detailed about the scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like forward_outlook_email, send_email, or reply_email. There are no usage examples, prerequisites, or exclusion criteria, leaving the agent to infer applicability from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden. It simply states 'Forward an Outlook email' without disclosing side effects (e.g., sending a message), required permissions, or irreversible actions. This is minimal and leaves the agent uninformed about behavioral nuances.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no filler. It front-loads the verb and resource, making it maximally concise and structured for quick parsing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 3 parameters, no annotations, and no output schema, a one-sentence description is inadequate. It does not address return values, side effects, or parameter constraints, leaving significant gaps for reliable agent use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any of the parameters (messageId, to, note). While the tool name implies messageId and to, the note parameter is unexplained, and none of the fields receive additional semantic value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Forward an Outlook email' clearly identifies the action (forward) and the resource (an Outlook email). However, it does not distinguish this from sibling tools like forward_email or reply_outlook, so it lacks sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description gives no context about preferred scenarios, prerequisites, or exclusions, leaving the agent without decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits. 'Get upcoming' implies a read-only operation but does not specify the time window, calendar scope, or output format, leaving behavioral ambiguity for a tool with no safety annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no unnecessary words, efficiently conveying the core function. It is concise and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is sparse: it does not define 'upcoming' (e.g., how many days ahead), does not mention whether it covers all calendars, and lacks an output schema. For a 0-parameter tool, the description provides minimal context, making it less complete for reliable invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Since the tool accepts no parameters (schema coverage 100%), there are no parameter semantics to clarify. The baseline score of 4 is appropriate as the description has nothing to add.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves upcoming Google Calendar events, using a specific verb ('Get') and resource ('Google Calendar events'). It distinguishes itself from sibling tools like create_calendar_event and check_freebusy by scoping to retrieving upcoming events, though it doesn't explicitly contrast with search_calendar.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like search_calendar or weekly_preview. The description gives no context about appropriate use cases, making it ambiguous for an agent selecting among calendar-related tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Get Calendly bookings and links,' which implies a read operation but gives no details about scope, return format, authentication, or potential limitations. This is insufficient for a tool with zero annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, short sentence ('Get Calendly bookings and links.') with no filler or redundant content. Every word contributes to the meaning, making it highly concise and appropriately front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite being a simple tool with no parameters or output schema, the description is too vague to be complete. The sibling tool 'get_calendly_links' suggests a potentially overlapping function, and the description doesn't clarify what 'bookings and links' means structurally or whether the response includes combined data. The lack of output schema and annotations makes this description minimally viable at best, but the ambiguity with the sibling lowers its completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the input schema is an empty object. Per the rubric, 0 params receives a baseline of 4. Since there are no parameters to explain, the description adds no parameter-related value but also doesn't need to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the verb 'Get' with resource 'Calendly bookings and links,' making the core action clear. However, it does not explicitly distinguish from the sibling tool 'get_calendly_links,' which could cause confusion about whether this tool returns both bookings and links or just links.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like get_calendly_links or cancel_calendly. The description does not mention any use cases, prerequisites, or exclusions, leaving the agent to infer the appropriate context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool gets links but does not clarify the output format, whether it is read-only, or any authentication requirements. Minimal information beyond the name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that conveys the essential function without unnecessary words. It is appropriately concise and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool, the description is mostly adequate, but it lacks differentiation from the sibling tool get_calendly and does not mention what the response contains. This is a minor gap in an otherwise simple tool context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema is fully covered. The baseline for 0 params is 4, and the description does not need to add parameter details. It correctly focuses on the tool's purpose.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves the user's Calendly scheduling links, with a specific verb ('Get') and resource ('your Calendly scheduling links'). The purpose 'to share with others' adds context, and it distinguishes from sibling tools like cancel_calendly or get_calendly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives such as get_calendly. The description implies use for obtaining links, but there is no mention of exclusions or alternative tools, leaving potential ambiguity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only says 'Check which services are connected,' which implies a read-only operation but does not clarify what 'connected' means, what response format to expect, or whether any side effects exist. The description is too thin to fully inform the agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that directly states the purpose. It is front-loaded and contains no unnecessary words. It earns its place efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 params, no output schema), the description is minimally viable but leaves gaps. It does not explain what 'services' are included, how the connection status is returned, or whether the user needs any setup. A more complete description would mention the response format or integration scope.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema coverage is 100% (vacuously). Per the rubric, a baseline of 4 is appropriate when no parameters exist. The description adds no parameter details, but none are needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Check which services are connected.' It uses a specific verb ('check') and resource ('services'), and it distinguishes itself from sibling tools by referring to the general state of connections rather than a specific service getter like get_slack or get_stripe.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for checking overall connection status, but it does not explicitly state when to prefer this over specific service getters (e.g., get_slack). It lacks exclusionary guidance, but the intended use is reasonably inferable from the name and description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only says 'Get,' implying a read operation, but does not explain what is returned, whether authentication is needed, or any other behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one concise sentence with no filler, directly stating the primary function. It is front-loaded and appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no output schema and no annotations, the description is too sparse. It does not explain what 'recent' means, how parameters affect results, or what the response contains, leaving significant gaps for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, and the description does not mention the 'limit' or 'status' parameters. Agents must infer their meaning from names and the enum, which is insufficient for correct invocation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get') and resource ('recent DocuSign envelopes and signature status'), making the purpose clear. It distinguishes from many siblings like send_for_signature and void_envelope, though it could potentially overlap with check_signature_status.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use the tool: when recent DocuSign envelopes and their statuses are needed. However, it does not provide explicit guidance on when not to use it or mention alternatives such as check_signature_status for specific envelope status.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for behavioral disclosure. It implies a read operation ('Get') but does not state whether it is read-only, what computations are performed, or what the return structure looks like. No mention of side effects or data refresh behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence, front-loaded with the action and resource. Every word serves a purpose, with no filler or redundant detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with one optional parameter, the description provides the core purpose but lacks detail on return format, scope, and edge cases. No output schema exists, so the description should clarify what 'summary and totals' means concretely. It is adequate but not rich.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema defines one optional parameter 'period' with clear enum values (week/month/year/all). The description's 'by period' aligns with this but does not explain the enum semantics. Since the schema is self-explanatory, the description adds marginal value beyond confirming the parameter's role.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets expense summary and totals by period. It uses a specific verb 'get' and resource 'expense summary/totals', which distinguishes it from write operations like log_expense. However, it doesn't explicitly differentiate from other getter tools that might also involve financial data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or comparison to similar getter tools. The only implicit hint is the period parameter, which suggests usage for period-based queries.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry the full burden of behavioral disclosure. It only states the core filter (unreplied sent emails) and a use case. It does not disclose how 'no reply' is determined, the scope of emails scanned, the output format, or the effect of optional parameters. This is insufficient for an agent to predict the tool's behavior confidently.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences, front-loaded with the primary purpose. Every word earns its place, and the 'Use when' clause adds practical guidance without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations, output schema, and any schema descriptions, the description must provide more context. It covers purpose and usage but omits parameter semantics, output format, and potential caveats. For a tool with minimal structured metadata, this is incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has two parameters (days, limit) with no descriptions and 0% schema description coverage. The description does not mention either parameter, leaving their meaning and usage entirely implicit. With no schema-compensating information, the agent is left to guess from parameter names alone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'find' and a clear resource 'emails you sent that have not received a reply', which precisely defines the tool's function. It distinguishes itself from siblings like get_inbox or get_sent by focusing on unreplied sent emails. The added 'Use when' phrase reinforces the purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a clear usage context: 'Use when someone asks what needs following up.' This is explicit about when to invoke the tool. However, it does not mention alternatives or when not to use it, so it lacks full differentiation from tools like get_sent or catch_me_up.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Get,' implying a read operation, but gives no detail on return format, authentication, rate limits, or whether it accesses live or cached data. This is minimal but not misleading.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that immediately conveys the action and target. Every word counts, with no redundancy or extraneous content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-output-schema tool, the description adequately names the resource but misses expected return shape or limitations. It is functional but leaves the agent without knowledge of what the response will contain, which is a clear gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description needs no parameter documentation. The baseline for 0-parameter tools is 4, and the description appropriately doesn't invent parameters or add unnecessary detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Get') and resource ('HubSpot CRM contacts and deals'), which clearly distinguishes it from siblings like get_salesforce or get_quickbooks. It loses a point because it doesn't specify whether it retrieves all records, supports filtering, or returns both entities combined.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, conditions, or related tools, leaving the agent to infer usage purely from the tool name and context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits, but it only states the action. It does not mention whether emails are marked as read, the limit of emails returned, or any authentication requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that efficiently conveys the core function. It is front-loaded and contains no superfluous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the tool is simple, the description lacks information about the return format or any secondary behavior. However, given zero complexity, it is minimally adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters to document, so the description need not add parameter semantics. The baseline of 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves unread emails from Gmail, distinguishing it from sibling tools like get_outlook_inbox and get_sent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as get_unified_inbox or get_outlook_inbox. The description simply states the function without context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns a master list of tracking files, implying a read-only operation, but does not mention any side effects, limits, or additional behavior. For a simple get tool, this is minimally adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence of nine words, immediately stating the action, resource, and scope. It contains no filler and is perfectly front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-parameter read tool, the description sufficiently conveys that it retrieves the master index of all tracking files. While it lacks details about the output format, the tool's simplicity and the clarity of the description make it largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema confirms an empty properties object. The baseline for 0-parameter tools is 4, and there are no parameter details needed, so the description does not lack anything.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' with the resource 'ExanorOS Knowledge Index' and further clarifies it as the 'master list of all tracking files.' This clearly distinguishes it from sibling tools like find_knowledge, which likely searches rather than returns the full index.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to choose this tool over alternatives such as find_knowledge. The description states what the tool does but gives no context on when it is appropriate to call it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the primary function ('Get top news headlines with AI summary') and does not reveal whether the operation is read-only, how results are formatted, or any potential side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short sentences, direct and front-loaded. It states the core function first, then a usage hint, with zero wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description gives a clear purpose and usage context, and mentions the output (headlines with AI summary). However, it omits details about the limit parameter and the response structure, making it somewhat incomplete despite the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50% (topics is described, limit is not), and the tool description adds no parameter details. The term 'top news headlines' might imply limit's purpose, but it does not explicitly clarify the limit or topics parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets top news headlines with AI summary, using a specific verb and resource. It distinguishes from unrelated siblings like get_weather or get_inbox, but does not explicitly differentiate from similar tools like morning_briefing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a clear usage context: 'Use for morning news or what is happening in the world.' It does not mention alternatives or exclusions, but the context is enough to guide the agent on when to invoke this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of conveying behavior. The word 'Get' implies a safe read operation, and no side effects are indicated. However, it does not describe what the status output looks like or any potential auth/network requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, straightforward sentence (8 words) that front-loads the verb and resource. There is no wasted content or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple, parameterless getter with no output schema, the description adequately conveys the tool's purpose. It lacks explicit details about the return format or edge cases, but these are not critical for such a simple status query.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters and is trivially fully covered. With no parameters to describe, the baseline for parameter semantics is 4; the description adds no parameter-specific detail, which is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' and identifies the exact resource 'Gmail out of office auto-reply status'. It clearly distinguishes this read-only tool from the sibling 'set_ooo' which performs the opposite action.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: call this when you need the Gmail out-of-office status. However, it does not explicitly state when to use this tool vs alternatives, nor does it mention any exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'Get unread Outlook emails', which implies a read operation but does not disclose whether it marks emails as read, returns only summaries, or has any side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that is front-loaded with the action and resource. Every word earns its place with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool, the description is mostly sufficient but lacks detail about return format or behavioral nuances. Without annotations or an output schema, more context about what the caller receives (e.g., list, count, fields) would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters and an empty input schema, so there are no parameter semantics to explain. With no parameters, the description does not need to compensate for schema gaps, earning a baseline of 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves unread Outlook emails, with a specific verb and resource. It distinguishes itself from sibling tools like get_inbox and get_unified_inbox by specifying 'Outlook' and 'unread'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like get_inbox or get_unified_inbox. The description implies usage for unread Outlook emails but does not state exclusions or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavior. It only says 'Get sent Outlook emails', which does not mention whether results are limited to metadata, whether authentication is required, pagination, or any other behavioral aspects. The safety of this read operation is implied but not explicitly stated, leaving behavioral transparency largely unaddressed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is structurally concise, but it is under-specified. It omits essential information about parameters and scope, making it insufficient rather than efficiently concise. For a tool with parameters and no annotations, this level of brevity is not 'appropriately sized'.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with two optional parameters that are undocumented, no annotations, and no output schema, the description is grossly incomplete. It does not explain what the parameters do, what the return format is, or any limitations. Sibling tools like get_outlook_inbox and get_sent exist, but without more context, an agent cannot reliably use this tool. It is barely above a minimal stub.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema defines two parameters (q and limit) with no descriptions, and the tool description does not clarify their meaning or usage. With 0% schema description coverage and no parameter info in the description, the agent is left to guess what q filters and what limit does. The description adds no value beyond the parameter names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get sent Outlook emails' clearly identifies the action (get) and resource (sent Outlook emails), which is specific and understandable. It distinguishes from sibling tools like get_outlook_inbox by explicitly referencing the 'sent' folder, though it does not mention alternative tools like get_sent. However, the brevity does not fully disambiguate from get_sent, so it loses a point.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives such as get_sent or get_outlook_inbox. The description only states what the tool does without any context about preferred use cases, exclusions, or prerequisites. With numerous sibling email tools, this lack of guidance makes it harder for an agent to select the right one.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of explaining behavior. It only states what is retrieved, but does not disclose the return format, whether it is a read-only operation, or any prerequisites/limitations, which is insufficient for full transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no wasted words. It is front-loaded with the action and resource, and the example contents add useful context without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple, no-parameter getter, the description adequately conveys what the tool returns (preferences, with examples). However, the absence of an output schema means the description could serve as the sole return specification, and it does not fully enumerate all possible preference fields or nuances. This is a minor gap, but acceptable given the low complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so the baseline score is 4. The description does not need to explain parameters, and the empty schema already communicates that no input is required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get user preferences' with a specific verb and resource, and lists example contents (automation level, tone, VIP contacts), making its purpose distinct from sibling tools like update_preferences.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, exclusions, or preconditions, leaving the agent to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Get' (implying a read) but does not mention data scope, freshness, authentication needs, or whether the period parameter affects the output. The description adds minimal context beyond the action itself.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise (five words) and front-loaded, but it is under-specified rather than appropriately sized. It omits critical information about the parameter and expected behavior, so brevity comes at the cost of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given one parameter, no annotations, and no output schema, the description is severely incomplete. It does not explain what the financial summary contains, how the period parameter works, or when to call this tool instead of related ones. The agent lacks essential context for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not mention the 'period' parameter at all. Although the enum values (month/quarter/year) hint at time periods, the description fails to explain how period affects the financial summary, so the parameter semantics are largely uncommunicated.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get QuickBooks financial summary' clearly states a specific verb (Get) and resource (QuickBooks financial summary). It is distinguishable from sibling write tools like qb_create_invoice and qb_record_payment, though it does not explicitly differentiate from similar read tools like get_expenses or get_stripe.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as get_expenses or get_stripe. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits but only says 'Get all pending reminders.' It implies a read operation but does not clarify whether reminders are marked as read, if authentication is required, or if there are other side effects. The vague term 'pending' could lead to misjudgment about what is returned or modified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no redundancies or fluff. It communicates the core function efficiently and earns full marks for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Though the tool is simple, the lack of an output schema and annotations means the description must explain what constitutes 'pending' and the return format. It does neither, leaving significant ambiguity for a data-returning tool. Without this context, an agent may not know what to expect or how to interpret results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters, so the schema completely covers the input. The description adds no parameter details, but none are necessary; the baseline of 4 applies for zero-parameter tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves pending reminders using the specific verb 'Get' and the resource 'pending reminders.' It distinguishes from sibling tools like set_reminder and dismiss_reminder by implying a read-only fetch, and the term 'pending' adds scope beyond a generic 'get reminders.'

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as get_followups or catch_me_up. The description does not mention context, exclusions, or when-not-to-use, leaving the agent to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden but only states that it retrieves data. It does not disclose whether q is a search query, how limit behaves, what 'all' returns, or any authentication or read-only implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that front-loads the action and resource. Every word contributes to the core meaning, with no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no annotations, no output schema, and three undocumented optional parameters, the one-line description is incomplete. It leaves significant gaps around query behavior, default type, limit handling, and return format.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, but it only echoes the entity types already present in the type enum. It adds no meaning for q or limit, leaving their semantics entirely unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get'), a clear resource ('Salesforce CRM data'), and scopes the resource with concrete entity types ('contacts, opportunities, accounts, tasks'). This clearly distinguishes it from sibling get_* tools for other systems and from sf_create_* write tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit guidance on when to use this tool versus alternatives like lookup_contact or sf_create_contact. The description only implies retrieval via the verb 'Get' but offers no context about search scenarios, default behavior, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description discloses no behavioral details. It does not mention pagination (limit), filtering (q), authentication requirements, return format, or any side effects. The description carries the full burden and fails to provide substantive transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler or repetition. It is appropriately brief, though slightly under-specified, but this under-specification is more a completeness issue than a conciseness issue.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should at least explain the return value, how q and limit affect results, and any special behavior like only returning metadata. The current description is too thin to allow correct invocation, especially given the ambiguous q parameter.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage for the two parameters, q and limit, and the description adds no meaning to them. The agent is left to guess what q expects (query syntax?) and how limit behaves, with no guidance in either schema or description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource ('Get sent Gmail emails'), clearly identifying the Gmail sent folder and distinguishing it from Outlook sent emails. However, it does not differentiate from similarly named tools like search_email or get_inbox.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives such as get_outlook_sent, search_email, or get_inbox. No when-to-use, when-not-to-use, or alternative tools are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does not state whether the operation is read-only (though implied by 'get'), what data is returned, or any limitations like time range or workspace scope. This is a significant gap for an unannotated tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence with no wasted words. It is front-loaded and appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is too minimal to be fully complete. It does not clarify what 'recent' means, whether DMs are included, or what the return format is. The absence of an output schema and annotations means the description should provide more context, especially given the existence of siblings like get_slack_dms.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema is complete with no properties. Per the rubric, a baseline of 4 is appropriate for 0 params. The description adds no parameter-specific details, but none are needed since there are no parameters to describe.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the clear verb 'Get' and specifies the resource 'recent Slack messages', but it does not distinguish between message types (e.g., channel messages vs DMs) and does not differentiate it from sibling tools like get_slack_dms or search_slack. It is clear but lacks sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like get_slack_dms or search_slack. It simply states the function without any context, exclusions, or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description 'Get Slack direct messages.' discloses no behavioral traits. It does not state return format, pagination, authentication requirements, or whether it returns sent vs. received DMs. The description relies entirely on the tool name for behavior, which is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no unnecessary words. It communicates the core purpose efficiently and is appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Although the tool is simple with no parameters and no output schema, the description does not explain what output to expect (e.g., list of messages, metadata, format). It also omits any details about the scope (e.g., all DMs or only unread). This incompleteness could lead to incorrect assumptions about the return data.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema shows an empty object. The baseline for zero parameters is 4, as there are no parameter semantics to explain. The description does not need to add parameter details, and none are missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action ('Get') and resource ('Slack direct messages'), using a specific verb and noun. It distinguishes itself from sibling tools like 'get_slack' (broader) and 'get_teams_dms' (different platform), making its purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives such as 'get_slack' or 'search_slack'. The description does not mention exclusions, prerequisites, or preferred contexts. For a tool with zero parameters, users would benefit from context like whether it returns only recent DMs or the user's own DMs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden but only lists the returned data points (MRR, ARR, active subscribers, recent payments, plan breakdown). It doesn't disclose potential caveats like authentication requirements, data freshness, or whether the data is for a connected account. For a read-only 'get' tool, this is acceptable but not thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence front-loads the verb and resource, then lists the dashboard contents via an em dash. Every word earns its place, and the structure is optimal for a tool with no parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless read tool with no output schema, the description adequately explains what data will be returned. It could mention whether the dashboard is for the connected Stripe account or include a note about data freshness, but the coverage is strong given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema provides full coverage by definition. The description has nothing to add beyond the schema, and per the baseline rule, a score of 4 is appropriate for a parameterless tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' with the resource 'Stripe revenue dashboard' and enumerates distinct metrics (MRR, ARR, active subscribers, recent payments, plan breakdown), clearly distinguishing it from sibling get_* tools like get_quickbooks or get_salesforce. It leaves no ambiguity about what data this tool retrieves.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context by naming Stripe revenue metrics, implying that this tool is the right choice when Stripe dashboard data is needed. It doesn't explicitly mention alternatives or exclusions, but the resource specificity makes the use case obvious among the many get_* siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states 'Get Teams direct messages,' which essentially repeats the tool name and offers no insights into read-only status, return format, required permissions, or potential side effects like marking messages as read.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence with no filler or redundancy. It is appropriately concise, though it adds little value beyond the tool name itself. The brevity is acceptable for a simple zero-parameter tool, but it could have been slightly more informative without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema or annotations are present, so the description should clarify what the tool returns or any scope limitations. It does not specify whether it returns message content, metadata, unread-only messages, or a list of conversations. For a complete picture, more context is needed even given the low complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there is nothing to document. The baseline for 0-parameter tools is 4, and the description does not need to compensate for missing parameter information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Get' and a clear resource 'Teams direct messages', which distinguishes it from sibling tools like get_slack_dms (Slack) and send_teams_dm (send versus get). The tool's purpose is unambiguous and well-scoped.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as get_slack_dms, get_inbox, or get_unified_inbox. There is no mention of appropriate contexts, exclusions, or prerequisites, leaving the agent to rely solely on the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds minimal behavioral context beyond the tool's name: it indicates both mailboxes are fetched at once. It does not disclose return format, ordering, deduplication, pagination, authentication requirements, or any other notable behaviors. With no annotations to fill the gap, this is a significant deficiency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence with no wasted words. It front-loads the primary function and is easily scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and no output schema, the description provides the core function but does not explain what the unified result looks like or how it differs from calling two separate inbox tools. It is adequate but relies heavily on the tool name and sibling context for full understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description is not required to explain parameter syntax or meaning. The baseline of 4 applies; the description adds nothing about parameters but none are needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool fetches Gmail and Outlook simultaneously, which identifies its purpose and distinguishes it from single-mailbox tools like get_inbox and get_outlook_inbox. However, it omits the word 'inbox' explicitly, relying on the tool name to convey the resource type.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus alternatives. The phrase 'simultaneously' implies it combines both Gmail and Outlook, but it does not explicitly mention when to choose it over get_inbox or get_outlook_inbox, nor does it mention any exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description bears full responsibility for disclosure. It does disclose the notable behavior of scanning the calendar for travel locations, which is a meaningful side effect. However, it omits details such as whether this requires special permissions, how travel is detected, or the format of the returned weather data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two clean sentences with front-loaded purpose. The first sentence states the core action, and the second adds the calendar integration. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description needs to be more complete. It does not explain the return value, how optional parameters like 'city' and 'days' behave when omitted, or how the calendar scanning interacts with the 'travel' parameter. This leaves gaps for an AI agent to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain all parameters. It gives a hint for 'travel' via 'travel locations' and 'days' via 'forecast', but does not explicitly map parameters. 'City' is self-evident, but the overall parameter semantics are only partially conveyed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and clearly identifies the resource ('current weather and forecast'), also adding a distinguishing behavior: scanning the calendar for travel locations. This separates it from all sibling tools, none of which are weather-focused.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use it (when weather info is needed) and the calendar scanning adds context for travel-related queries. It does not explicitly exclude any cases or name alternatives, but no other sibling tool provides weather, so the guidance is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden for behavioral disclosure. It only states the action, providing no information about duplication behavior, required permissions, optional fields, or return values. This is a bare minimum statement that adds nothing beyond the tool's name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is only one sentence, but this is under-specification rather than conciseness. It does not fulfill the need to explain tool behavior or parameters, and every word is essentially redundant with the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters, no annotations, and no output schema, the description is severely incomplete. It lacks essential context about the contact creation process, field meanings, error cases, and expected outcomes, making it inadequate for an agent to use correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It does not mention any parameters, nor does it hint at field requirements or types. The agent must rely entirely on the schema, which also lacks descriptions, leaving parameter semantics unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Create a HubSpot contact' clearly identifies the action (create) and the resource (HubSpot contact), distinguishing it from SF and Outlook contact tools. However, it does not explicitly differentiate from the generic 'create_contact' sibling, so it is clear but lacks explicit scoping.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives like sf_create_contact or lookup_contact. No context on prerequisites, target audience, or typical scenarios is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It merely states a create action without mentioning required fields, permissions, idempotency, side effects, or response format. This is minimal to the point of providing no useful behavioral information.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single brief sentence, but it is under-specified rather than appropriately concise. It provides no additional value over the tool name and omits critical details, making it an ineffective use of the description space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the low complexity of a create action with 4 parameters, the description should explain what a HubSpot deal is or outline the parameter semantics. With no annotations, no output schema, and 0% schema coverage, the description is completely inadequate for an agent to select and invoke this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 4 parameters with 0% description coverage, and the tool description adds no information about what stage, amount, dealName, or contactId mean or how they should be used. The description fails to compensate for the schema's lack of documentation, leaving parameter semantics entirely unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Create a HubSpot deal' directly restates the tool name 'hubspot_create_deal' without adding any new meaning or scope. It identifies the verb and resource but is essentially a tautology, offering no differentiation from sibling tools beyond the obvious.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives like hubspot_update_deal or hubspot_create_contact. No context, prerequisites, or exclusions are mentioned, leaving the agent without direction for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must explain behavior, but it only states the obvious write action. It does not mention permissions, reversibility, or how contactId is used if omitted.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no redundant words, making it structurally efficient. However, it is perhaps too brief, but conciseness itself is good.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is insufficient for a tool with no annotations or output schema. It does not explain parameter semantics or usage context, making it incomplete despite low complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 2 parameters with 0% description coverage. The description does not explain the purpose or format of 'note' or 'contactId', so it fails to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool logs a note on a HubSpot contact, using a specific verb and resource. This distinguishes it from sibling tools like hubspot_create_contact or hubspot_update_contact, as it is the only one specifically for note logging.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as when to log a note vs update a contact. It lacks context about prerequisites or scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits. It only states 'Update' with no details on partial vs full update, required permissions, or error behavior. This is insufficient for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no redundant phrasing. However, it is too brief to be fully helpful, though it does not waste words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no output schema and no annotations, so the description must provide context. It fails to mention response format, error conditions, or usage constraints, making it inadequate for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description adds no parameter explanations. The parameter names are self-evident, but no additional semantics are provided, such as which fields are updatable or the format of contactId.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Update') and resource ('a HubSpot contact'), making the tool's purpose unambiguous. However, it does not distinguish between sibling tools like hubspot_create_contact or update_contact.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as hubspot_create_contact or hubspot_update_deal. There is no mention of prerequisites or typical scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden. It discloses only the general action ('update') without context on side effects, authorization requirements, partial vs full update behavior, or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, succinct sentence with no redundancy. It front-loads the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, the description lacks important context such as update semantics, prerequisites, and expected behavior. It is minimally viable but leaves significant gaps for an agent to invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description adds minimal semantic value. While it names 'stage or amount' as the updatable fields, it does not clarify the required dealId, value formats, or whether one or both fields must be provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool updates a HubSpot deal's stage or amount, using a specific verb and resource. It differentiates from sibling tools like hubspot_create_deal (create) and hubspot_update_contact (update contact).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool relative to alternatives. The description only states what it does, leaving the agent to infer usage. It does not mention when not to use it or direct to alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses the primary write action and the auto-create side effect, but it does not mention whether it appends to existing sheets, handles duplicates, or requires specific permissions. These are notable omissions for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short sentences, front-loaded with the core action. Every phrase earns its place, making it efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 6 parameters, only 2 required, no output schema, and no annotations, this description is insufficiently complete. It does not explain return values, error behavior, or parameter meanings, leaving the agent to guess at critical details for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only 1 of 6 parameters (category) has a schema description, and the tool description does not elaborate on any parameter. Required fields 'amount' and 'description' lack format or interpretation details, especially since amount is typed as string. The description fails to compensate for the low 17% schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb ('Log') and resource ('expense tracker in Google Drive'), making its purpose unambiguous. It distinguishes itself from sibling tools like get_expenses (read operation) and append_to_sheet (generic write) by targeting the expense logging domain.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'to your expense tracker' implies the intended use case, and 'Auto-creates spreadsheet if needed' gives context that no prior setup is required. However, it does not explicitly contrast with alternative tools (e.g., append_to_sheet) or state when not to use it, leaving usage guidance implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full behavioral burden. It states the core action but does not disclose what happens on multiple matches, not-found cases, or whether it searches across all sources. It also lacks any mention of rate limits or permissions. It is not misleading, but adds minimal depth beyond the tool name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no extraneous words. Every word contributes to the purpose. It is an exemplary model of conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple, one-parameter read tool, the description is adequate in explaining the basic action and result (email or phone). However, it lacks context about when to use this tool instead of lookup_outlook_contact or other search tools, and since there is no output schema, it does not describe the return format in detail. This is a clear gap but not critical for a straightforward lookup.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides only a string parameter 'q' with no description (0% coverage). The description compensates by clearly indicating that 'q' is the name to search for ('by name'). This clarifies the primary parameter's meaning, though it does not specify formatting (e.g., full vs partial name). Still, it gives significant semantic value beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs a lookup of a contact's email or phone by name. The verb 'look up' and resource 'email or phone' are specific, and it is distinguished from siblings like create_contact and lookup_outlook_contact by the lookup behavior and general scope. It could be more explicit about the source (e.g., 'from your contacts'), but it is sufficiently clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. Sibling tools like lookup_outlook_contact suggest a more specific variant, but the description does not mention such alternatives or any context where this tool is preferred. The agent receives no exclusionary or selection information.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only lookup operation, but does not detail whether it searches the local address book, Exchange, or other sources, nor does it mention case sensitivity, partial matching, permissions, or error behavior. The description is minimal and leaves these aspects opaque.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that immediately communicates the tool's function without any filler or repetition. It efficiently uses the limited space to convey the essential purpose and parameter semantics.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple lookup tool with one parameter and no output schema, the description is largely sufficient. It clarifies the resource and the search criterion. While it lacks details about return values or limitations, the simplicity of the tool and the absence of an output schema mean the description does not need to over-explain. It is complete enough for an agent to understand the core intent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has one parameter 'q' with no description (0% schema coverage). The description adds meaning by stating the lookup is 'by name', directly indicating that 'q' represents the contact name. However, it does not clarify formatting, formatting requirements, or whether partial names are supported, leaving some ambiguity.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Look up a Microsoft contact by name' clearly identifies the specific action (look up), resource (Microsoft contact), and the lookup criterion (by name). This distinguishes it from sibling tools like create_outlook_contact or lookup_contact, which may have broader or different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool versus alternatives, such as search_outlook or get_outlook_inbox. It does not mention prerequisites, exclusions, or conditions that would direct an agent to this tool over similar ones. The usage context is only implied by the tool's name and description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must fully disclose behavior. It only says 'get', hinting at a read-only operation, but does not explain what platforms are covered, what a 'full briefing' includes, or any side effects/requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. It is maximally concise for the amount of information provided.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description should explain what a 'morning briefing' actually returns or aggregates. It does not mention specific platforms, data types, or the format, making it incomplete for an agent deciding whether to invoke it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema has 100% coverage (empty). The baseline for 0 params is 4, and the description does not need to add parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb ('Get') and resource ('full morning briefing'), so the basic action is understandable. However, it does not differentiate from similar siblings like 'catch_me_up' or 'weekly_preview', leaving the exact scope ambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives. No contexts, prerequisites, or exclusions are mentioned, leaving the agent to guess.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It lists action names but doesn't disclose side effects (e.g., archiving moves the email, trash may be permanent) or required permissions. It adds little beyond the enum values already in the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. It is appropriately minimal for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations, output schema, and parameter descriptions, the tool needs more context. The description fails to cover when to use, how to get messageId, and what the outcomes are, making it incomplete for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% and the description does not explain messageId format, how to obtain it, or clarify the action values beyond repeating them. No additional meaning is added for parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: applying read/unread, archive, or trash actions to an Outlook email. It uses a specific verb and resource, and distinguishes from sibling tools like forward_outlook_email or reply_outlook by focusing on state-changing actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided about when to use this tool over alternatives. There is no mention of prerequisites (e.g., obtaining a messageId) or exclusions, despite a rich set of sibling email tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('create') without revealing any side effects, such as whether the invoice is a draft or sent immediately, required permissions, or what happens on success/failure. This is a significant gap for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence that is perfectly front-loaded and contains no filler. Every word earns its place, making it an example of excellent conciseness for a simple tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is deceptively simple but has no annotations, no output schema, and undocumented parameters. The description fails to provide any context beyond the bare action, leaving the agent without essential information about required fields (beyond schema), expected behavior, or integration specifics. It is inadequate even for a basic tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, and the description does not add any meaning to the parameters (customerName, amount, dueDate, description). The agent is left to infer semantics solely from parameter names, with no guidance on formats, units, or relationships between fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Create a QuickBooks invoice' uses a clear verb ('create') and a specific resource ('QuickBooks invoice'), making the tool's purpose immediately obvious. It also naturally distinguishes itself from sibling tools like qb_record_payment and get_quickbooks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives (e.g., qb_record_payment for payments, log_expense for expenses). There is no mention of prerequisites, such as the customer needing to exist in QuickBooks, or any context in which this tool should be preferred. Usage is only implied by the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states the action without detailing side effects, authentication requirements, idempotency, or error handling. For a mutation tool, this is a significant gap, similar to the update_drive example.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no unnecessary words, making it concise and front-loaded. It conveys the core action effectively, though it could be expanded with useful detail without becoming verbose. The structure is appropriate for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and only three loosely specified parameters, the description is insufficient for an agent to correctly invoke the tool. Missing information includes how to identify the invoice, expected payment amount format, and success/failure behavior, leaving critical operational details unaddressed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, and the description does not explain any parameter meanings, formats, or relationships. The parameter names (invoiceId, paymentAmount, customerName) are somewhat self-explanatory, but paymentAmount's string type and the optionality of customerName remain unclear without additional context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Record a QuickBooks payment' uses a specific verb ('record') and resource ('QuickBooks payment'), clearly distinguishing it from sibling tools like qb_create_invoice (create) and log_expense (expense). It conveys the action unambiguously.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when one needs to record a payment in QuickBooks, but it provides no explicit when-to-use vs alternatives, prerequisites, or exclusions. It matches the 'implied usage' level, as the context is clear from the tool name but not elaborated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully disclose behavior. It only says 'read' without explaining return format, supported file types beyond Sheets/Docs, or any access requirements. Very little beyond the operation name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence with no redundant wording, well front-loaded. However, the extreme brevity borders on under-specification, so it does not earn a perfect conciseness score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No annotations or output schema exist, and the description omits parameter behavior, supported file types, and what the read operation returns. It is minimally adequate for a simple read tool but leaves significant gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 2 parameters (fileId, range) with 0% description coverage. The description never mentions parameters or their expected usage; fileId and range are only nominally inferable from schema names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description states 'Read a Google Sheet or Doc' – a specific verb and resource. It clearly distinguishes from siblings like append_to_sheet, create_doc, and read_onedrive_file.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives such as read_onedrive_file or search_drive. The description only implies usage for reading Google files, with no exclusions or alternative recommendations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.