Higgs Hub

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It indicates a mutating operation but does not disclose what happens if a sheet with the same title already exists, whether changes are reversible, or what response is returned.

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, front-loaded sentence that directly states the operation and target. There is no filler or redundant restatement of 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?

For a mutating operation with no annotations, no output schema, and sparse parameter documentation, the description is too minimal. An agent would benefit from knowing failure behavior, whether the tab is created at a specific position, and any permission or mailbox requirements beyond the mailbox parameter description.

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 only 33%, so the description must compensate. It does provide some semantic mapping: 'worksheet tab' suggests what 'title' is for, and 'existing workbook' contextualizes 'workbookId'. However, it adds no detail on constraints, uniqueness, or format 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 states a specific verb and resource: 'Add a new worksheet tab to an existing workbook.' It clearly distinguishes from creating a new workbook (create_excel_workbook) and from the Google-sheet equivalent (add_google_sheet_tab), though it does not name those alternatives explicitly.

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 when-to-use or when-not-to-use guidance is provided. The phrase 'existing workbook' implies the workbook must already exist, but it does not explain prerequisites, such as creating the workbook first or checking list_excel_workbooks for a valid workbookId.

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 restates the mutation ('adds a tab') without mentioning prerequisites, duplicate-title behavior, permissions, or 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 clear sentence with no filler. The action is front-loaded and every word earns its place.

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 and no output schema, the description is too thin. It omits how to obtain spreadsheetId, what happens on duplicate tab titles, and any return or confirmation behavior, leaving the agent to infer from sibling 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 only 33%, with only mailbox described. The description does not explain spreadsheetId or title, though 'new worksheet tab' weakly implies title is the tab name. It fails to compensate for the low 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 states a specific verb ('Add'), a specific resource ('new worksheet tab'), and a target ('existing spreadsheet'), which clearly distinguishes it from create_google_spreadsheet and add_excel_sheet. The title and description align perfectly.

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 such as add_excel_sheet, or on prerequisites like the spreadsheet already existing. There are no exclusions or alternative tool references.

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 and does disclose key behaviors: it appends after the last data row, interprets values as typed (numbers/dates parse, '=' becomes a live formula), and notes the lack of a raw-text option. However, it omits details like permissions, error behavior, or return value, which are relevant 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?

Two sentences with zero filler. The primary purpose is front-loaded, followed by essential behavioral notes. Every clause adds value; 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?

While the description covers the core behavior and type parsing, it lacks an output schema and does not mention what the tool returns (e.g., success confirmation, row count, or error conditions). It also does not address prerequisites like existing workbook/sheet or permission needs. For a 4-required-param mutation tool without annotations, this is a notable 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?

Schema description coverage is 50%, and the description adds substantial meaning to the 'values' parameter (parsing behavior, formula interpretation) beyond the schema's generic 'Rows of cell values'. It does not explain 'sheet' or 'workbookId', but those are fairly self-explanatory, and the description compensates for the most complex parameter.

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?

States a specific verb (Add/append) and resource (rows to an Excel worksheet) with a precise placement rule (after the last row holding data). Clearly distinguishes from sibling tools like update_excel_range (modifies existing cells) and append_google_sheet_rows (Google Sheets) via the explicit Excel context and the contrast with 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?

Provides clear context that this is the standard way to add new records to a tracker, implying it is for appending rather than updating. The contrast with Google Sheets ('no option to store text exactly as given') offers a usage hint for when to prefer the alternative, but it does not explicitly name sibling tools or state when not to use 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 full behavioral burden. It discloses the critical value-parsing behavior: numbers/dates parse and leading = becomes a formula, plus the RAW option to avoid that. It also specifies the append location. This is substantial transparency 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?

Two sentences with the purpose front-loaded and the key behavioral nuance second. No filler; every clause adds value, and the structure is easy to scan.

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 five-parameter append operation with no output schema, the description covers the core behavior, value handling, and gives a range example. It does not mention error cases or alternative tools, but the essentials for correct invocation are present. Slightly more would be ideal but not required.

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 60%, and valueInput lacks a description in the schema. The description explains the enum values and their effect, adding meaning beyond the schema. It also clarifies the interpretation of the values parameter, partially compensating for the incomplete 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: 'Add rows after the last row that holds data' and frames it as 'the usual way to add records to a tracker.' This distinguishes it from update/clear operations and from the Excel sibling. The specific resource and behavior 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?

It implies the primary use case (adding records) and hints at the distinction from overwriting, but does not explicitly mention alternatives like update_google_sheet_range or clear_google_sheet_range. The context given is enough for an agent to infer when to use it, though 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?

With no annotations, the description carries the full behavioral burden. It does disclose a genuinely useful non-schema fact—the 1000-message batch cap—and the move-equivalent behavior of combining add and remove in one call. However, it never discloses the mutating nature of the operation, potential side effects of removing INBOX, idempotency, or partial-failure behavior, which an agent would benefit from knowing for a label-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?

Two sentences, no filler. The core action and batch limit are front-loaded in the first sentence, and the second sentence earns its place by clarifying the move semantics that would otherwise be ambiguous. Every phrase contributes.

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 4-parameter, 2-required tool with no output schema and no annotations, the description covers the central call pattern well but omits practical invocation details: how to obtain label IDs, the implication of both label arrays being optional in the schema, behavior on partial batch failure, and the return value. The move analogy is strong, but an agent would still need to infer or probe several 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 coverage is only 25%—only mailbox is described—so the description must compensate for the undocumented messageIds, addLabelIds, and removeLabelIds. It partially does: explaining that add and remove happen 'in the same call' and that the destination label maps to addLabelIds while INBOX/source maps to removeLabelIds. But it doesn't specify where label IDs come from (e.g., list_gmail_labels), whether at least one of the arrays must be supplied, or messageId format, leaving clear gaps.

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 opens with a specific verb+resource: 'Add and/or remove labels on up to 1000 messages at once.' This clearly distinguishes it from siblings like create_gmail_label, delete_gmail_label, and rename_gmail_label, which operate on the label definitions themselves, not on messages. The folder-move analogy further anchors 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 gives clear contextual usage guidance: it frames the tool as 'Gmail's equivalent of moving messages between folders' and explains the exact recipe—'add the destination label and remove INBOX (or the source label) in the same call.' This tells an agent when to reach for it versus Outlook's move_messages. It stops short of explicitly naming alternatives or stating when-not-to-use scenarios, so it doesn't earn a 5.

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 and does well: it discloses the asynchronous 'only stages a request' behavior, the browser review/approval step, and the owner-unrestricted rule. The warning about never accepting the PIN in chat is critical behavioral guidance that prevents agent misuse. This significantly exceeds minimum disclosure.

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 three sentences, each serving a purpose: core operation, constraints, and approval-flow warning. It is front-loaded with the action and parameter selection guidance, and contains no filler. Efficiency without loss of critical 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?

For a tool with no annotations and no output schema, the description covers all necessary invocation details: target identity, role null semantics, owner restriction, exact-one constraint, workspace scope, and the staged approval process. The only minor omission is a note about return/success response, but that is not essential for correct invocation. The definition is complete enough for an agent to call 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 coverage is 100%, so baseline is 3; the description adds value by imposing the 'exactly one of member or apiKey' exclusivity that is not enforced by the schema. It also reinforces that role=null means the workspace's default role, aligning with the schema description. The workspace param is left to the schema, which is acceptable.

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 opens with the specific action 'Move one member (by email) or one API key (by name) into an access role', naming the exact resource and operation. It distinguishes this from sibling role-manipulation tools (create_access_role, delete_access_role) and from set_member_workspace_role by focusing on assignment into an access role with the default-role null option.

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 explicit constraints on invocation: 'Give exactly one of member or apiKey', and clarifies that owners cannot be assigned a role. It also gives workflow guidance by explaining the request is only staged and that the owner must approve it in the browser, including the explicit 'Never ask for or accept the PIN in chat'. It does not name alternative tools, but the context is clear enough for an agent to decide when to use 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?

With no annotations, the description fully carries the burden of behavioral disclosure. It explicitly states that this tool only stages a request and requires the owner to approve via a browser link with their agent PIN, and it gives a security directive to never ask for the PIN in chat. This discloses asynchronous behavior and an important operational constraint, going beyond what a simple 'cancel' would imply.

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 with no wasted words. It front-loads the core purpose, then delivers the essential behavioral caveat and security warning. Every sentence earns its place, and the structure is easy to scan quickly.

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 only two parameters, no output schema, and no annotations, the description is fully sufficient. It explains the purpose, the prerequisite (owning the workspace), the workflow (staged approval), and a critical safety rule (never ask for PIN). An agent can call this tool correctly with no additional guidance.

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 already has 100% description coverage for both parameters. The tool description adds value by explaining the purpose of the email parameter ('by the invited email') and giving practical guidance for the optional workspace parameter: 'Only needed when you own more than one — list_workspaces shows them.' This clarifies when the parameter should be provided, exceeding the baseline of 3.

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 ('cancel') and a precise target ('a pending invitation to a workspace you own, by the invited email'). It clearly distinguishes from siblings like invite_member or remove_member by focusing on pending invitations, and the term 'cancel' is unambiguous. The title and name align perfectly, and the description adds the critical qualifier of workspace ownership.

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: it is for canceling a pending invitation, not for removing an already-accepted member. It also explains the approval workflow, which tells the agent when to expect a deferred result. However, it does not explicitly name alternative tools for different scenarios (e.g., using remove_member for active members), though the distinction is implicit from the wording.

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 clearly states the operation is non-destructive to formatting and rows, and adds a human-interaction requirement (confirm before clearing). It does not mention effects on formulas, data validation, or permissions, but the core behavior is well disclosed.

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 sentences, no redundancy. The primary action is stated first, and the user-confirmation safety note is appended without clutter. All words earn their place.

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 covers the core behavior but omits crucial context: parameter format (e.g., 'range' syntax like A1:B2), prerequisites (workbook/sheet existence), and any impact on formulas or calculations. With no output schema and low parameter schema coverage, this is insufficient 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?

Schema coverage is only 25% (only mailbox has a description), and the tool description provides no additional parameter information. The description does not explain how to specify 'range', 'sheet', or 'workbookId', leaving the agent to guess naming conventions and formats. This is a significant gap for a low-coverage 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 states a specific verb ('Empty') and resource ('the values in a range'), and clarifies it leaves formatting and rows intact, distinguishing it from row deletion or value replacement. The tool name and title also differentiate it from clear_google_sheet_range and update_excel_range.

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 use case: clearing values while preserving formatting and row structure. It includes a safety guideline about confirming before clearing user data, but does not explicitly name alternatives or state when to prefer this over update_excel_range or clear_google_sheet_range.

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, and it does well by disclosing that only values are emptied while formatting and rows remain, and by requiring user confirmation. It does not mention irreversibility or permission requirements, but the confirmation directive signals the destructive nature adequately.

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 the core action and what is preserved, and the second gives a clear safety instruction. Every sentence earns its place and the most important behavioral detail 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 covers the purpose, the non-destructive-to-format behavior, and a confirmation requirement, which is solid for a simple clear operation. However, it omits the expected range syntax, how spreadsheetId should be supplied, and what a successful response looks like, leaving some 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?

Schema coverage is only 33% and the description does not compensate. It adds no format guidance for 'range' or 'spreadsheetId', and the word 'range' simply restates the parameter name. The 'mailbox' parameter is already described in the schema, so the description provides little additional parameter-level meaning.

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 ('Empty the values') and resource ('a range') and adds a valuable nuance: formatting and rows are preserved. It is clear about what the tool does, though it does not explicitly distinguish itself from sibling tools such as clear_excel_range or update_google_sheet_range.

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 ask the user before clearing anything they did not just create is a useful operational guideline. However, the description does not explicitly state when to choose this tool over alternatives or mention exclusion cases, so usage context is only implied rather than fully specified.

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 burden. It does disclose one behavioral detail: Google stamps the completion time itself, which tells the agent not to supply a time. However, it does not mention idempotency, effects on already-completed tasks, error handling, or return behavior. With no annotations, this is only partial disclosure.

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 short sentences, front-loaded with the primary action. The second sentence is an informative behavioral note with no filler. Extremely efficient.

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 3-parameter mutation tool with no annotations and no output schema, the description is too sparse. It lacks instructions on how to retrieve valid listId/taskId values, what happens if the task is already completed, or what the response contains. The timestamp note adds value, but the absence of parameter sourcing guidance and flow details leaves an agent under-informed.

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 33%; only mailbox is described. listId and taskId have no description in either the schema or the description. The names suggest their content but the description provides no guidance on where to obtain them (e.g., list_google_tasks, get_google_task). The tool name does add 'Google' context but not enough to compensate for the coverage 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?

States a specific action ('Mark a task done') on a specific resource (Google task). The second sentence clarifies a key behavior (Google sets the completion time). Distinguishable from siblings like complete_outlook_task by the 'Google' qualifier in the name and 'task done'. Clear 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?

The description implies the use case (complete a Google task) but provides no explicit when-to-use guidance or exclusions. It does not contrast with update_google_task, delete_google_task, or the Outlook counterpart. The behavioral hint about timestamp is a small usage cue, but not enough to rise above implied 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. It does disclose one behavioral consequence: completed tasks drop out of list_outlook_tasks by default. However, it does not mention reversibility, permission requirements, or other side effects of marking a task complete.

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 short sentences with no filler. The action is front-loaded and the behavioral note is relevant. Every word earns its place.

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 does not explain where to obtain listId and taskId (e.g., from list_outlook_tasks), does not mention the return value or errors, and lacks guidance on idempotency. For a mutation tool with no annotations and no output schema, this is a significant 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?

Schema description coverage is only 33% (only mailbox is described). The description does not compensate by explaining listId or taskId, leaving two required parameters without semantic guidance beyond their 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 states a specific verb and resource ('Mark a task as done'), making the primary purpose unambiguous. It implicitly distinguishes from complete_google_task by platform, but it does not explicitly contrast with update_outlook_task, which could also modify task 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?

No guidance is given on when to use this tool versus alternatives like update_outlook_task or delete_outlook_task. The only additional information is a consequence (tasks drop out of list_outlook_tasks), not a usage condition or exclusion.

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 critical behavioral trait: 'This only stages a request: the owner opens the link in their browser, reviews it, and approves it there with their agent PIN.' This is beyond what annotations provide (none are given), and it also includes a security-relevant instruction: 'Never ask for or accept the PIN in chat.' This is exactly the kind of behavioral context an agent needs to avoid a serious error.

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 three sentences, each earning its place: the first states the action and initial state, the second explains the follow-up workflow, and the third discloses the approval flow and PIN safety rule. It is front-loaded with the core purpose and scoping constraint, and there is zero waste.

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 2-parameter tool with no output schema, the description is complete. It covers the initial state of the role, the follow-up tools to use, the workspace ownership prerequisite, the approval flow, and the PIN safety rule. An agent has everything it needs to call this tool correctly and avoid a security mistake.

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 100%, so the schema already documents both parameters. The description adds context about the workspace parameter ('Only needed when you own more than one — list_workspaces shows them'), which is useful. However, it doesn't add much about the name parameter beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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 and resource: 'Create a named access role in a workspace you own.' It clearly distinguishes this from siblings like set_access_role_capability, set_access_role_mailbox_access, and assign_access_role by explaining the role starts with all capabilities and mailbox access enabled, then must be narrowed with those sibling tools. This is a clear, specific purpose that an agent can act on.

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 explicitly explains the workflow: create the role, then narrow it with set_access_role_capability and set_access_role_mailbox_access, then assign people with assign_access_role. It also states the prerequisite that you must own the workspace, and that the workspace parameter is only needed when you own more than one. This is explicit when-to-use guidance with named alternatives and sequencing.

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 behavioral burden. It discloses the return value (id and link), the default location behavior, and the conditional requirement for parentFolderId. It does not address permissions or conflict behavior, but those are minor for a simple creation 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?

Three sentences with no wasted words. The core action comes first, followed by return value and then the placement caveat. The structure is easy to parse and intentionally ordered.

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 creation tool with three parameters and no output schema, the description provides enough to invoke it correctly: required fields are implied by the schema, the optional parameter is explained, and the return value is stated. Minor gaps like overwrite behavior and permission requirements do not block correct 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 already documents mailbox and parentFolderId, and the description adds useful location semantics for parentFolderId. However, the required 'name' parameter has no schema description and the description does not clarify what the name refers to. With 67% schema coverage, the description only partially compensates for that 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 states the action ('Create'), the resource ('a new empty .xlsx workbook'), and the location ('in the user's OneDrive'). It also mentions the returned id and link, and the 'new empty' qualifier distinguishes it from tools like create_google_spreadsheet or add_excel_sheet.

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 gives practical placement guidance: the workbook lands in the top level of the drive unless parentFolderId is provided, and parentFolderId becomes required when mailbox access is folder-limited. It does not explicitly name sibling alternatives, but the context is clear enough for an agent to decide when to use 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 present, so the description carries the transparency burden. It discloses one important behavioral trait: the folder defaults to My Drive root when no parent is given. It does not cover permission requirements, duplicate-name handling, or return values, but the core creation behavior is clear.

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 states the action and the useful default-parent behavior 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 create tool with no output schema and no annotations, the description is adequate for attempting a call. However, it does not state what the tool returns (e.g., folder ID) or how it behaves when a folder with the same name already exists, which an agent might need for follow-up actions.

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 low at 33%, but the description adds meaning for parentItemId by explaining the parent default. The 'name' parameter is inferable as the new folder name, and mailbox already has a detailed schema description. Still, explicit per-parameter guidance for name and parentItemId is 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 action ('Create a new folder in Google Drive') and adds the parent/root behavior, which separates it from siblings like create_onedrive_folder. It does not explicitly name a sibling, so it falls just short of a full 5.

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 intended use is implied: call this when creating a Google Drive folder, optionally under a given parent. However, there is no explicit when-to-use, when-not-to-use, or comparison with alternatives such as create_google_spreadsheet or create_onedrive_folder.

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 does disclose the key non-sending behavior and the sending-disabled edge case. However, it omits other relevant behavior such as whether the draft lands in the Drafts folder, whether it returns a draft ID, or whether any permissions beyond a connected mailbox are needed.

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?

Three short sentences with no filler. The core action is front-loaded, the user-facing role is clarified in the second sentence, and the environment condition is a valuable third sentence. Every sentence earns its place.

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 straightforward draft-creation action and conveys the essential no-send distinction. However, with no output schema and no annotations, the agent is left without information about the return value, confirmation behavior, or any content-format expectations, making it incomplete for a 7-parameter 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 only 29% (2 of 7 parameters described: mailbox and replyToMessageId). The tool description adds no parameter-level guidance for to, cc, bcc, subject, or body, and does not clarify body format (plain text vs HTML) or reply-threading details beyond the schema's brief replyToMessageId note.

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 opens with a specific verb and resource: 'Write a draft into the mailbox without sending it.' This clearly distinguishes it from send_gmail_message and create_outlook_draft, and the follow-up 'The person opens and sends it themselves' reinforces the no-send intent.

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 explicitly contrasts drafting with sending and even provides a concrete use-case condition: 'Works even when a workspace has switched sending off.' It does not explicitly name send_gmail_message as the alternative for immediate sending, but the distinction is strongly implied and easy for an agent to act on.

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 transparently reveals the default archiving side effect and the server-side persistence behavior. It does not mention prerequisites like the label needing to exist, but the core behavioral traits are clearly disclosed.

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 sentences with no wasted words. The first sentence front-loads the action and effect, and the second adds a valuable persistence detail. Every sentence earns its place.

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 6-parameter creation tool with no annotations and no output schema, the description covers the core behavior, default side effect, and server-side persistence. It is slightly incomplete in not noting that addLabelId must reference an existing label or that no return value is specified, but it is adequate 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 100%, so the baseline is 3. The description adds mild context by summarizing 'sender/subject/query criteria' and noting the default archive behavior, but it does not add meaning beyond what the schema already provides for mailbox or addLabelId.

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 and resource ('Create a Gmail filter') and explains what it does: automatically labels and by default archives incoming mail matching sender/subject/query criteria. This clearly distinguishes it from siblings like apply_gmail_labels (which acts on existing messages) and create_gmail_label (which only creates a label).

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 context is implied: use this for automatic server-side handling of future incoming mail. However, it does not explicitly state when not to use it or name alternatives such as apply_gmail_labels for existing messages or create_inbox_rule for other mail systems.

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 disclosure burden. It reveals one useful behavior — that '/' in the name creates nested labels — but omits other traits an agent would want for a create operation: behavior on duplicate label names, whether the created label ID is returned, and any label-count limits. The description is not misleading, but it is thin on behavioral detail.

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 sentences with no filler: the core action is front-loaded, and the nested-label rule earns its place immediately after. The example is compact and concrete rather than 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?

For a two-parameter tool with no output schema and no annotations, the description covers the central operation and the main format nuance, while the schema handles mailbox selection. However, it never states what response to expect (e.g., created label ID) or how duplicate labels are handled, which matters for follow-up workflows like apply_gmail_labels. It is adequate but leaves clear 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 coverage is 50%: the mailbox parameter is well-documented in the schema (email format plus a pointer to list_authorized_mailboxes), while name has no schema description. The description compensates for the name gap by teaching the slash convention for nested labels with a concrete example. This adds real meaning beyond the bare string type in 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 first sentence names a specific verb and resource ('Create a new Gmail label'), so an agent can tell this is a create operation on Gmail labels rather than mail folders or other resources. The slash-nesting tip further clarifies what a label name means. It doesn't explicitly contrast with sibling tools like rename_gmail_label, delete_gmail_label, or apply_gmail_labels, but the verb+resource pairing is unambiguous enough.

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 nested-label example ('Clients/Acme') provides a how-to hint but no guidance on when to choose this tool over alternatives such as create_mail_folder, apply_gmail_labels, or rename_gmail_label. There are no when/when-not conditions or exclusions. Given the large sibling set of label- and folder-related tools, an agent gets little routing help from the 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?

No annotations are provided, so the description carries the full burden. It only states the action and does not disclose side effects, return values, authorization requirements, idempotency, or any other behavioral traits. The description does not explain what happens on success or failure, making it insufficient for an agent to predict 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 sentence that is front-loaded with the action and purpose, with no filler or redundant content. It efficiently communicates the core functionality and a use case, making it highly scannable for 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?

Given the tool has 4 parameters, 2 required, no output schema, and no annotations, the description is too sparse to be complete. It doesn't mention return values, how to specify timezone/description, or any post-creation behavior. An agent would need to rely on the schema and external knowledge to use it 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?

Schema description coverage is 50% — mailbox and timeZone are described, but name and description are not. The tool description adds no parameter information at all, so it does not compensate for the missing schema descriptions. It doesn't explain what 'name' or 'description' mean, nor clarify the role of mailbox or timeZone beyond what the schema already provides.

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 action (create) on a specific resource (secondary calendar) on the account, and gives a concrete use case (keeping client/project events separate). It clearly distinguishes from siblings like create_google_calendar_event or create_outlook_calendar by naming the resource (Google calendar) and the 'secondary' qualifier.

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 gives a clear context when this tool is useful (for client/project events separation) but does not mention alternatives or explicitly say when not to use it. It doesn't differentiate from create_google_calendar_event or other creation tools, leaving the agent to infer that this is for calendars, not events. No exclusions or alternative routing 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, the description carries the full burden of behavioral disclosure. It does disclose that adding guests emails them invitations, that no guests means no notifications, and that addVideoMeeting attaches a Google Meet link. However, it doesn't mention side effects like creating an event in a default calendar when calendarId is omitted, or any authorization requirements. It adds some useful context beyond the schema but misses other important behavioral aspects.

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 four sentences, front-loaded with the core action ('Create an event') followed by the most critical usage details. It is efficient and avoids redundancy, though it could be slightly more structured. The information is dense and relevant, with 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?

Given the tool has 10 parameters, 60% schema coverage, no annotations, and no output schema, the description is incomplete. It fails to explain what happens without a calendarId (likely default calendar), doesn't mention return values, and ignores optional parameters like location and description. The agent may not know how to correctly invoke it in all cases, especially regarding default calendar behavior and expected response.

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 description adds meaningful context for key parameters: it clarifies the date format distinction between all-day and timed events (start/end), explains the invitation behavior for attendees, and describes the effect of addVideoMeeting. This goes beyond the schema's descriptions, which cover 60% of parameters. It doesn't address calendarId, location, or description, but those are self-explanatory from their names. The description compensates well for the parameters it touches.

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 'Create an event' which, combined with the tool name 'create_google_calendar_event', clearly identifies the action and resource. It distinguishes from sibling tools like create_google_calendar (which creates a calendar) and create_outlook_calendar_event, though it doesn't explicitly name those alternatives. The verb 'Create' and resource 'event' are specific, but the description alone could be slightly ambiguous without the title.

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 usage details on date formats, guest invitations, and video meeting attachment, but it never explains when to use this tool versus its alternatives (e.g., create_outlook_calendar_event). It does not mention any conditions or exclusions for using this tool, leaving the agent to infer based on the title. This is a significant gap given the large sibling list with similar creation 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 disclosure burden. It explains the creation behavior, default placement, the condition requiring parentFolderId, and the return value (id and link). It doesn't discuss permission needs or side effects on existing files, but for a create operation the key behavior is well covered.

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?

Three tight sentences with no fluff. The main action leads, followed by the return value and then the placement nuance. Every sentence contributes operational information an agent needs.

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, the description usefully states the return value and the key location rule. It doesn't clarify what happens to the default sheet when sheetTitles are provided, or any permission prerequisites, but it gives enough for correct basic 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 coverage is 75%, and the description adds meaning beyond it: the 'top level unless parentFolderId' default location behavior and the fact that sheetTitles create named tabs. It also frames parentFolderId as a placement control, reinforcing the schema's restriction note.

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 names a specific action and resource: creating a new spreadsheet in the user's Drive, with optional tabs. It also states the output (id and link) and the default location, which clearly distinguishes it from siblings like create_excel_workbook or create_gdrive_folder.

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 gives clear usage context: the new file lands at the Drive top level unless parentFolderId is provided, and explains when parentFolderId is required. It doesn't explicitly compare against alternative spreadsheet creation tools, but the Drive/mailbox framing implies the Google Sheets 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 carries the behavioral burden and covers the non-obvious quirks: due times are discarded, priority is not supported, and parentTaskId creates a subtask. It does not describe return values or side effects, but the disclosure is substantial for a create 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?

Three sentences, all informative: the core action is front-loaded, and each following sentence adds a distinct behavioral caveat. There is no filler or repetition of the schema except where it reinforces an important quirk.

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 sufficient for a simple creation call, but with no output schema or annotations it leaves out how to obtain listId, which fields are required, and what the tool returns. The behavioral caveats are useful, yet an agent still needs to infer some setup and postconditions.

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 description partially compensates for the 50% schema coverage by restating the due-date behavior and the subtask meaning of parentTaskId in natural language, and it warns that no priority parameter exists. But notes, listId, and title still have no semantic explanation beyond their names, and most of the parentTaskId/dueDate content duplicates schema descriptions.

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 opens with a specific action and object — 'Add a task to a list' — and the title/name confirm it creates a Google task. It is distinguishable from siblings like create_google_task_list and complete_google_task by naming task creation, though it does not explicitly contrast with update/complete variants.

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?

'Add a task to a list' conveys the core use case, and the subtask note adds a creation variant, so usage is implied. However, there is no explicit guidance about when to prefer this over complete_google_task, update_google_task, or list_google_tasks, and no 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 carries the full burden. It only states 'Create a new task list' with no information about side effects, permissions, idempotency, or what the tool returns. 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 one short sentence, which is front-loaded and concise, but it is under-specified. It does not waste words, but it omits essential context that an agent needs. It is not verbose, but it is not appropriately sized for the information it should convey.

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 only two parameters and no output schema, a minimal description might be acceptable, but the description fails to explain what a task list is, what the tool returns (e.g., the list ID), or how it differs from similar tools. The presence of many sibling tools makes this lack of differentiation problematic.

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 describes only the mailbox parameter (50% coverage). The description does not explain the title parameter or its purpose, nor does it add any additional meaning to either parameter. The agent must guess that title is the name of the list, which is not stated.

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 ('Create') and resource ('task list'), and the tool name clarifies it's for Google Tasks. It distinguishes from create_google_task (which creates a task, not a list), but it does not explicitly mention Google in the description itself, relying on the name. It is clear and unambiguous enough for an agent to know the intended 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?

The description provides no guidance on when to use this tool versus its siblings like create_google_task or create_outlook_task_list. There is no mention of context, prerequisites, or alternatives. An agent is left to infer usage from the name and schema.

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 and does disclose a meaningful trait: the rule executes server-side in Exchange and persists after this tool is unavailable. It also flags the non-obvious requirement that at least one condition must be supplied, though it does not discuss permissions, limits, or response 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?

Three short sentences with no filler; the core action is front-loaded, followed by the persistence trait and the validation caveat. Every sentence earns its place.

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 an 8-parameter create tool with fully documented parameters and no output schema, the description covers action, persistence, and the central validation rule. It could add that the rule applies to future mail or that it can be managed via delete_inbox_rule/list_inbox_rules, but nothing essential is missing for a competent 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?

Schema coverage is 100%, so the schema already documents every parameter. The description adds value by encoding a cross-parameter constraint not visible in the schema's required list: at least one condition is required, and by summarizing the sender/subject criteria.

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 first sentence names a specific verb and resource ('Create an inbox rule') and states the behavior: automatically moving incoming mail matching sender or subject criteria into a folder. This clearly differentiates it from list/delete inbox rule tools and Gmail filters.

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?

It implies usage via 'Runs server-side in Exchange' and persistence, which suggests using it when a rule must survive independently of this tool. However, it never explicitly contrasts it with sibling alternatives such as create_gmail_filter or states when not to use 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?

There are no annotations, so the description carries the full burden of disclosing side effects and requirements. It does disclose the primary creation behavior and the nesting semantics, but it doesn't mention permissions, duplicate behavior, whether the operation is reversible, or what the response looks like. For a mutation tool, these are meaningful omissions.

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 sentences with no filler. The core action comes first, and the optional-parameter behavior follows immediately. Every word contributes to usability.

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 relatively simple, but with no annotations and no output schema, the description should clarify more than it does. It covers the creation action and the key optional param, but it leaves out return value, error-prone input expectations, and any distinction between folder types or services when similar mail-related tools exist.

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 only 33%, so the description must compensate. It adds useful semantics for parentFolderId, explaining that omitting it creates a top-level folder. However, it doesn't clarify the meaning of displayName or how mailbox maps to folder scope beyond what the schema already provides.

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 and resource: 'Create a mail folder.' It distinguishes itself from siblings like create_gmail_label or create_inbox_rule by focusing specifically on folders, and the nesting instruction adds scope clarity. It doesn't explicitly contrast with alternatives, but the core purpose is 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 gives one concrete usage rule: pass parentFolderId to nest, omit for a top-level folder. However, it doesn't explain when to choose this tool over alternatives such as create_gmail_label or create_inbox_rule. The guidance is implied by the tool name rather than explicitly stated.

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 behavioral burdenasi. It discloses the mutation (create), the default parent location, and the non-merging suffix behavior. It does not mention permission requirements or error behavior, but the core side effects are clear.

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 sentences with no filler. The primary action and default behavior come first, and the important edge-case behavior is included without unnecessary 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 create operation with three parameters and no output schema, the description covers the key invocation details: target OneDrive, parent location, and naming behavior. It does not describe the return value, but this is a minor gap for a folder creation 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 coverage is only 33%, but the description compensates by explaining parentItemId (defaults to drive root) and name (suffix on conflict). The mailbox parameter is already welldocumented in the schema, so the description fills the most important gaps.

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?

States a specific verb, resource, and behavior: creates a folder in OneDrive under an optional parent. The conflict-handling detail (suffix rather than merge) makes it clearly distinguishable from sibling folder creation tools and clarifies its semantics.

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 implies use for OneDrive folder creation through the tool name and first sentence, but it does not explicitly state when to choose this tool over alternatives like create_gdrive_folder or create_mail_folder. Guidance is implied rather than stated.

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 identifies the operation as creating a calendar, but it does not mention the response/return value, duplicate-name behavior, permissions required, or any side effects beyond creation. This is minimal transparency for a mutating 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 no filler. It states the core action first, then adds a relevant use case. Every word earns its place.

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 two-parameter create tool, the description is adequate but not complete. It leaves gaps around name parameter semantics and the result of the operation. An agent can likely infer how to call it, but not what to expect back or how name collisions are handled.

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 only 50%. The mailbox parameter is documented in the schema, including a pointer to list_authorized_mailboxes, but the name parameter has no description. The tool description does not compensate by explaining the expected format or meaning of name, so one parameter remains semantically under-specified.

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 a new calendar on the account') and explains the practical purpose ('keeping a client's or project's events separate from the default one'). It identifies the resource as a calendar, distinguishing it from event-creation siblings like create_outlook_calendar_event, though it does not explicitly name the alternative.

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 use case: separate a client's or project's events from the default calendar. This implies when the tool should be used, but it does not state exclusions or point to alternatives such as creating calendar events or listing calendars.

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 important behavioral traits: adding guests emails each an invitation from the user's address, no guests notifies nobody, and addVideoMeeting attaches a Teams link without recording/transcribing. These go beyond the schema and annotations (which are absent), providing valuable context about side effects. It doesn't mention permissions or reversibility, but the key side effects are covered.

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?

Three sentences with zero waste. The most important behavioral facts (invitation side effects, Teams link behavior) are front-loaded. Every sentence earns its place.

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 10-parameter tool with no output schema, the description covers the critical behavioral aspects: guest invitations, all-day event semantics, timezone handling, and Teams link behavior. It doesn't explain return values, but the absence of an output schema lowers the bar. The description is complete enough for an agent to call the tool correctly without opening the schema.

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 60%, and the description adds meaning to key parameters: attendees (emails invitations), addVideoMeeting (Teams link behavior), and the all-day event semantics for start/end. The timeZone parameter is well-documented in the schema, and the description reinforces the importance of setting it. The description compensates for the 40% gap by explaining the behavioral implications 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 states a clear verb and resource: 'Create an event' in Outlook Calendar. It distinguishes itself from siblings like create_google_calendar_event and update_outlook_calendar_event by the resource and action, though it doesn't explicitly name a sibling. The title and description align well.

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 on when to use this tool: creating an Outlook calendar event. It doesn't explicitly state when not to use it or name alternatives, but the sibling list makes the distinction obvious. The note about confirming with the user before inviting guests is a useful usage guideline.

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 behavioral burden — and it does so well. It discloses the non-sending behavior, the human-in-the-loop flow, and the conditional behavior when sending is disabled. It omits return values and failure modes, but the critical behavioral traits are clearly stated.

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?

Three sentences with zero waste. The primary behavior is front-loaded in sentence one, sentence two clarifies the human-in-the-loop flow, and sentence three adds a distinguishing condition. Every sentence earns its place.

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 core decision (draft vs send) and the sending-disabled scenario are well covered, but with no output schema, no annotations, and 71% of parameters undocumented, an agent is left without return-format guidance or parameter-level help. Adequate for the primary action, with clear gaps on operational detail.

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 29% (2 of 7 params documented), so the description must compensate. It adds a single parameter-relevant point — the draft lands in the mailbox — but says nothing about to/cc/bcc/subject/body semantics or formatting. This fails to offset the low coverage for a 7-parameter 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 opens with 'Write a draft into the mailbox without sending it' — a specific verb and resource with the central distinction from send tools made explicit. It clearly separates this tool from siblings like send_outlook_message and send_outlook_reply by stating that the human opens and sends it themselves.

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 gives two concrete usage conditions: use this when a person needs to review/send the draft themselves, and use it when a workspace has switched sending off. It does not explicitly name alternative tools, but the draft-vs-send contrast makes the routing decision clear without requiring an agent to open other schemas.

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 mentions optional fields, but does not disclose side effects (e.g., whether reminder is switched on by default), permission requirements, or potential errors like invalid mailbox or list. For a write operation with no annotations, more transparency is needed.

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, concise sentence that clearly states the action and lists key optional attributes. No wasted words, front-loaded with the primary purpose.

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 9 parameters and no output schema, the description is thin. It does not explain how to get listId, what happens with timeZone defaulting, or the behavior of reminderDateTime. Given the complexity (many optional fields and potential pitfalls), more guidance is needed to avoid misconfiguration.

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 description coverage is 56%, and the description adds meaning by summarizing which parameters are optional (due date, reminder, importance, notes). It does not explain how to obtain listId, but the schema covers mailbox, and the description hints at the purpose of optional parameters. It partially compensates for the uncovered parameters (e.g., categories, timeZone).

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 it creates a task in a To Do list and lists the optional fields (due date, reminder, importance, notes). It distinguishes from siblings like create_outlook_calendar_event, but does not explicitly differentiate from create_outlook_task_list, though the resource is clear enough.

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?

It implies usage for creating tasks, but does not state when to use it versus update_outlook_task or complete_outlook_task, nor any prerequisites like having the list ID. Siblings exist for task management, but no explicit guidance is given.

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 confirms a create operation but does not mention permissions, whether an existing list with the same name is affected, naming constraints, or what the response contains.

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. For a simple creation tool, this length is appropriate.

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 annotations and no output schema, so the description must provide more context. It does not clarify what happens after creation, how the result is returned, or how this differs from creating a task versus a task list.

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 50%: mailbox is documented, but displayName has no schema description. The tool description adds no parameter-level meaning and does not compensate for the undocumented displayName parameter.

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 action ('Create') on a specific resource ('a new Microsoft To Do task list'). It clearly differentiates from sibling create_outlook_task, which creates an individual task rather than a list.

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 versus alternatives such as create_outlook_task, create_google_task_list, or create_outlook_calendar. The mailbox parameter references list_authorized_mailboxes, but that is parameter-level guidance, not 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, the description carries full disclosure duty and succeeds: it reveals that the operation is only staged, not immediately destructive, and that approval happens out-of-band in the owner's browser. The PIN warning is a critical behavioral guardrail that prevents the agent from soliciting credentials in chat. It also flags the default-role restriction, which is non-obvious.

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?

Three dense sentences with no filler: action, prerequisites/exclusion, approval flow, and security rule each earn their place. The most important caveats are front-loaded before the procedural 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 two-parameter tool with no output schema or annotations, the description gives everything needed to execute correctly: target role, prerequisite move, default-role exclusion, owner-approval flow, and the PIN safety rule. If anything, the only implicit piece is that the tool returns a link for the owner, but that is inferable from 'opens the link.'

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 descriptions already cover both parameters comprehensively at 100% coverage, so the description does not need to re-explain them. It adds relevant context — such as the default-role restriction — but does not describe parameter formats. Baseline 3 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?

States a precise action on a specific resource — delete an access role — and immediately scopes it to roles nobody follows. It is clearly separable from siblings like assign_access_role, create_access_role, and rename_access_role. The staged-request nuance is disclosed without obscuring the intent.

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?

Gives explicit prerequisites: members and API keys must be moved to another role first, naming assign_access_role as the tool to do it. It also states an exclusion (the workspace default role cannot be deleted) and explains that the owner must approve the request. This is enough for an agent to know when and how to invoke it responsibly.

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. It discloses that deletion is permanent and bypasses the trash, implying irreversibility. The confirmation instruction also signals high-risk behavior. It does not cover permission side effects or what happens to shared links, but the most critical behavioral traits are stated.

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 sentences with zero filler. The core action is front-loaded, followed by the critical 'bypasses trash' caveat and the confirmation directive. Every word earns its place.

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 tool, it covers the essential behavioral context (permanence, bypass, confirmation). However, the lack of any description for itemId creates a real gap—an agent does not know what value to supply. There is no output schema, but that is acceptable for delete operations. Overall, adequate but not fully 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?

Schema coverage is only 50%: mailbox has a description, but itemId has none. The description adds no parameter guidance—it never mentions how to identify the file or folder (e.g., what itemId is). It does not compensate for the undocumented itemId, leaving the agent without clear meaning for a required parameter.

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-resource pair: 'permanently delete a Google Drive file or folder.' It also notes 'bypasses trash,' which differentiates it from normal deletion and clarifies scope. Among many sibling delete_* tools, this clearly targets Google Drive items, so an agent can distinguish it without opening schemas.

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?

It provides an explicit usage instruction: 'Ask the user to confirm before calling this,' which is crucial for a destructive operation. It does not mention alternatives or when-not-to-use, but the resource type is unambiguous among siblings. The confirmation requirement is a strong guideline, though exclusions are absent.

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 of disclosing behavior. It states the delete action implicitly but says nothing about permanence, irreversibility, permissions required, or what happens if the filter does not exist.

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 filler. It front-loads the core action, though a little more useful context could have been added without hurting clarity.

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 destructive tool with two required parameters, no annotations, and no output schema, the description is too thin. It leaves the agent unsure how to source filterId and unaware of the operation's side effects.

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 only 50%. The mailbox parameter is well described, but filterId has no description and the description text does not explain where to find it or what format it takes. This is a meaningful gap for a required parameter.

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 and resource: 'Delete an existing Gmail auto-filing filter.' This unambiguously distinguishes the tool from siblings like delete_gmail_label or list_gmail_filters, and the title reinforces the same meaning.

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 gives no guidance on when to use this tool versus alternatives, nor does it mention that list_gmail_filters should be used to obtain a valid filterId. The only contextual hint is in the schema for mailbox, which points to list_authorized_mailboxes.

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 action is permanent, explicitly says messages are not deleted but only unlabeled, and requires user confirmation before invocation. This covers the key side effects and safety expectations an agent needs, going well beyond the annotation baseline.

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 sentences with no filler. The core action is front-loaded, followed by a key behavioral caveat and a safety instruction. Every clause earns its place, and there is no redundant 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?

For a destructive action with no annotations and no output schema, the description covers the core behavioral aspects: permanence, effect on messages, and user confirmation. It does not mention how to discover the labelId (e.g., via list_gmail_labels), but that gap is more a parameter-semantics issue than a completeness issue. Overall it is mostly complete for the tool's 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?

Schema description coverage is 50% (mailbox has a description, labelId does not). The tool description does not compensate for the undocumented labelId parameter; it does not explain what a label ID is, how to obtain it, or its format. The only parameter-related context comes from the schema, which is insufficient for the half that is 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 states 'Permanently delete a Gmail label' with a specific verb and resource, clearly distinguishing it from sibling tools like create_gmail_label, rename_gmail_label, and list_gmail_labels. It also clarifies the scope (messages are not deleted, only unlabeled), which further separates it from message-deletion 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 gives an explicit 'when to call' instruction: ask the user to confirm before calling, because the action is permanent. It does not explicitly name alternative tools or state when not to use it, but the message-unlabeling clarification implies a distinction from message deletion. This is clear, actionable context for an agent.

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 and does a strong job: it discloses cascade destruction ('every event on it'), irreversibility ('WARNING: this is not recoverable'), and the required confirmation step. It does not address permission/ownership requirements or behavior on a non-existent/primary calendar, leaving minor 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?

Three front-loaded sentences: action and scope first, then restriction, then warning and confirmation instruction. No repetition or filler; each sentence carries distinct weight, which is appropriate for a destructive 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?

For a 2-param tool with no output schema, the description covers core semantics, the primary-calendar constraint, and the irreversible nature of the action. The main gap is that the calendarId parameter is left undocumented in both the schema and the description, with no pointer to list_google_calendars as the source of valid IDs.

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 only 50%: mailbox is well-described, but calendarId has no schema description and the tool description adds nothing about its format, provenance, or how to obtain it (e.g., via list_google_calendars). The agent must infer calendarId's meaning from the tool name and sibling list, which is a material gap for a required parameter.

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 precise verb plus resource ('Delete a secondary calendar and every event on it') and adds clear scope by excluding the primary calendar. It is clearly about calendar deletion rather than event deletion, though it does not name the nearest sibling delete_google_calendar_event to differentiate explicitly.

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 gives clear context: it applies only to secondary calendars ('The primary calendar cannot be deleted') and mandates user confirmation before invocation ('Ask the user to confirm before calling this'). It does not name any alternative tool (e.g., delete_google_calendar_event) or spell out when a delete should be avoided in favor of another action, so it stops short of the top tier.

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 exist, so the description carries the full behavioral burden. It discloses a major hidden consequence: guests are emailed a cancellation that cannot be undone. This is strong transparency for a delete operation, though it could also clarify series vs. single-occurrence behavior in more detail.

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?

Three short sentences with no filler. The action is front-loaded, followed by the irreversible side effect, then the required user confirmation. Every sentence earns its place.

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 covers the essential context for a delete tool: what is deleted, the external notification side effect, irreversibility, and the need for user confirmation. However, the optional calendarId parameter and expected response behavior are not addressed, and there is no output schema to fill that 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?

Schema description coverage is only 33%: only mailbox has a description. The description does not explain eventId or calendarId, their formats, or their relationship to deleting an event vs. an occurrence. With low schema coverage, the description should compensate but does not.

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 the specific action 'Delete' and the resource 'Google Calendar event', with the added nuance 'one event or one occurrence'. This clearly distinguishes it from siblings like delete_google_calendar and delete_outlook_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?

The description gives explicit pre-call guidance: 'Ask the user to confirm before calling this.' This is important for a destructive operation. It does not explicitly name alternative tools like update_google_calendar_event or move_google_calendar_event, so it lacks exclusion 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose that deletion is not the default and should only occur on explicit user request, which is useful. However, it does not state that deletion is irreversible/permanent or describe any side effects 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?

Two short sentences with no filler. The core action comes first, and the important usage caveat follows immediately. Every word earns its place.

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 with no output schema, no annotations, and low parameter coverage, the description leaves gaps. It gives good usage guidance but does not explain how to obtain listId/taskId or what happens after deletion. It is minimally adequate but not 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?

Schema description coverage is only 33%; only mailbox is documented. The description adds nothing about listId or taskId, and those parameters are undocumented in the schema. Since coverage is low, the description should have compensated, but it does not.

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 and resource: 'Delete a task.' It also explicitly distinguishes deletion from completion, which is the key sibling distinction given complete_google_task exists. An agent can immediately tell this tool's purpose from the title and first sentence.

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 gives explicit guidance: 'Completing it is almost always what the user means — only delete when they say delete.' This directly tells the agent when to avoid this tool and prefer completion, which is a clear alternative-usage condition even though complete_google_task is not named.

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 the destructive and irreversible nature ('no recycle bin') and instructs the user to confirm first. This is important behavioral context beyond the basic deletion action. With no annotations, the description carries this responsibility effectively.

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 sentences with no redundancy. The main action is front-loaded, and the critical warning follows immediately. Every word serves a purpose.

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 deletion tool with no output schema, the description covers the essential aspects: what is deleted, the irreversibility, and the need for confirmation. It does not include extra details like return values, which are likely not needed.

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 description does not provide any additional information about the parameters. The schema only describes the 'mailbox' parameter; 'listId' is left undocumented. With 50% schema coverage, the description should compensate but doesn't.

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 Tasks list), and specifies that it deletes every task in it. This distinguishes it from sibling tools like delete_google_task which deletes a single task.

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 does not explicitly mention when to use this tool instead of delete_google_task or other delete tools. The usage is implied by the resource type, but no explicit guidance or 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 carries the full burden. It says only 'Delete an existing inbox rule,' which conveys a destructive operation but does not disclose side effects, irreversibility, permissions, or what happens to emails governed by the rule. This lacks behavioral transparency beyond the verb 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 a single clear sentence with no redundant words. It is appropriately concise for a simple delete operation.

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 destructive tool with no annotations, no output schema, and an undocumented ruleId parameter, this description is too sparse. It omits usage context, side effects, and parameter sourcing, leaving an agent to guess important operational 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 coverage is 50%: mailbox has a description, but ruleId does not. The description adds no parameter meaning, notably failing to explain how to source ruleId (e.g., via list_inbox_rules). It does not compensate for the schema's 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 'Delete an existing inbox rule' clearly states the specific action (delete) and the resource (inbox rule). It is unambiguous and distinct from siblings like create_inbox_rule or list_inbox_rules, though it does not explicitly name them.

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, how to obtain the required ruleId, or any prerequisites. There is no mention of list_inbox_rules as a companion tool or any caveats about deleting rules.

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 disclosure burden and delivers: it warns that messages inside the folder are deleted too and that Outlook does not unfile them first — a non-obvious destructive consequence. The confirmation requirement also signals irreversibility, exactly the context an agent needs before invoking a delete.

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?

Three sentences with no filler. The one-line purpose is followed immediately by the front-loaded WARNING about message deletion, then an actionable precondition. Every sentence earns its place.

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 2-param destructive tool with no output schema, the description covers the critical context: destructive scope, platform behavior, and the confirmation protocol. The only gap is that folderId provenance is never referenced, and there is no note about what a successful deletion returns.

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 exactly 50%: mailbox is well documented in the schema (email format, pointer to list_authorized_mailboxes), but the required folderId has no schema description and the tool description adds nothing about it. At this coverage level the description should compensate by explaining where folderId comes from (e.g., list_mail_folders); it doesn't, leaving a required parameter opaque.

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 and resource ('Delete a mail folder') with no ambiguity. The operation is inherently distinct from sibling tools like create_mail_folder, rename_mail_folder, and merge_mail_folders, and no sibling performs folder deletion.

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 clear procedural guardrails for a destructive tool: move messages worth keeping out beforehand and ask the user for confirmation before calling. It doesn't name explicit alternatives or when-not-to-use cases, but the precondition and confirmation requirement give the agent a solid usage protocol.

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 behavioral burden. It discloses that deletion goes to the recycle bin, is recoverable for the tenant's retention window, and advises confirming with the user first. It does not detail side effects like folder contents or permissions, but the key recovery behavior is covered.

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?

Three concise sentences, each adding meaningful information: action, recovery behavior, contrast with GDrive, and user-confirmation guidance. No fluff or repetition.

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 itemId provenance is a notable omission: an agent is not told to get it from list_onedrive_items or search_onedrive_items. The description is otherwise suitable for a straightforward delete operation with no output schema.

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 mailbox has a schema description; itemId is an undocumented bare string. The description does not explain what itemId refers to or how to obtain it, so the 50% schema coverage gap is not compensated at all.

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?

States the specific action 'Delete a OneDrive file or folder' with a clear resource and scope. It also distinguishes itself from the Google Drive equivalent, and the name aligns with the behavior.

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 clear context by contrasting with the 'Google Drive equivalent which is permanent', helping an agent choose between delete_onedrive_item and delete_gdrive_item. It does not explicitly list all alternatives or state exhaustive when-not conditions, but the context is strong.

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 clearly states the destructive scope (calendar and every event), irreversibility, and the need for user confirmation. This is strong transparency for a deletion 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?

Three short sentences, each adding essential information: the action and scope, a key constraint, and a required safety step. No filler or repetition.

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 destructive operation with no output schema and no annotations, the description covers the critical aspects: what is deleted, irreversibility, the default-calendar restriction, and user confirmation. It could mention how to find a calendarId or explicitly point to list_outlook_calendars, but the core calling context is adequately handled.

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 50%: mailbox is documented, but calendarId is a bare string with no description. The tool description does not clarify what calendarId should contain or how to obtain it, so the undocumented parameter is left to the agent to infer.

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?

States a specific action and resource: 'Delete a calendar and every event on it.' This clearly distinguishes the tool from delete_outlook_calendar_event and other sibling delete operations.

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 usage conditions: the default calendar cannot be deleted, the operation is irreversible, and the agent must ask for user confirmation first. It does not name alternative tools, but the 'default calendar cannot be deleted' exclusion and confirmation requirement give clear operational 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?

No annotations provided, so description carries full burden. It discloses the critical behavior of emailing cancellation to guests and irreversibility. However, it doesn't mention permissions, failure handling, or recurrence specifics beyond 'event or occurrence'.

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 sentences, zero fluff, action first. Every word is necessary, and the critical caution about guests is prominently placed.

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 destructive tool with no output schema and no annotations, the description covers essential behavior but omits guidance on sourcing eventId (e.g., from list_outlook_calendar_events). A brief mention would make it 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?

Schema coverage is 50% (mailbox has a description, eventId has none). The description adds no parameter information. eventId remains completely undocumented, leaving the agent unsure how to obtain it. Description fails to 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 states the verb 'Delete' and the resource 'event or occurrence', distinguishing it from sibling tools like delete_outlook_calendar which deletes an entire calendar. No ambiguity about what it 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?

It gives clear guidance on the destructive nature (immediate, irreversible, emails guests) and instructs to ask user confirmation. It doesn't explicitly name an alternative tool, but the caution is strong and implies when to avoid using 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 burden of disclosing the destructive nature of the operation. It clearly states that the deletion is permanent and that To Do has no recycle bin, which is the critical behavioral fact an agent needs before calling this 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?

Two compact sentences deliver the action, the consequence, and the preferred alternative. There is no filler, and the most important fact — permanent deletion — 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 tool's purpose and irreversibility are well covered, but the description does not tell an agent how to obtain the required listId and taskId, and there is no output schema to clarify the return value. For a destructive tool with three required parameters, this leaves a gap in operational 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?

Schema description coverage is only 33%, and the description adds no parameter-level meaning. The mailbox parameter is documented in the schema, but listId and taskId are left as bare strings with no explanation of where they come from or how they relate to Outlook task lists and tasks.

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 precise action ('Permanently delete a task') on a specific resource, immediately clarifying that this is not a reversible or soft-delete operation. It also distinguishes itself from complete_outlook_task, which is the closest sibling, by framing deletion as the exception.

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 gives explicit routing guidance: prefer complete_outlook_task unless the task was created in error. This tells an agent both when to avoid this tool and the condition under which deletion is appropriate.

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 fully discloses the irreversible deletion of all tasks and the lack of a recycle bin. This is exemplary transparency beyond typical 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 concise, front-loads the critical warning, and provides actionable instruction in just two sentences. Every sentence earns its place.

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 destructive delete operation with no output schema, the description covers all essential information: what it does, consequences, and required user confirmation. Nothing critical is 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?

Schema coverage is only 50%; the mailbox parameter is described in the schema, but listId is not. The description adds no parameter detail, leaving the meaning of listId ambiguous for the agent.

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 it deletes a To Do list, distinguishing it from other delete operations on different resources. 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?

Explicitly instructs the agent to ask for user confirmation before calling, and the warning makes the destructive nature clear. This is a strong usage guideline that prevents accidental misuse.

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 discloses that it finds groups of labels sharing a name, implying a grouping behavior, but does not explicitly state that it is read-only or describe the return format. For a find operation, the absence of a read-only hint and output structure is a notable 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, concise sentence that front-loads the primary action and scope. Every word adds value, with no filler or repetition.

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 a single parameter, no annotations, and no output schema, the description is adequate but leaves gaps. It does not specify the return format (e.g., list of label groups, IDs) or explicitly confirm that the operation is non-destructive. For a simple tool this is acceptable but not fully 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?

Schema description coverage is 100% and the mailbox parameter already has a detailed description in the schema. The tool description adds no extra parameter semantics, so the baseline of 3 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 states a specific verb (Find) and resource (user labels), with a clear condition (share the same name) and scope (within one mailbox). It distinguishes from sibling find_duplicate_mail_folders by specifying 'user labels' and from merge_duplicate_gmail_labels by its find-only intent.

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 as a precursor to merging by saying 'likely duplicates worth merging', and the name/sibling context makes it clear this is for Gmail labels. However, it does not explicitly state when not to use it or mention alternative tools, though the context is reasonably clear.

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. It does disclose a meaningful behavioral scoping rule (parent-scoped only, cross-parent duplicates ignored), but it does not state whether the operation is read-only, what the result format is, or whether it returns folder IDs needed for merging.

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 sentences with no filler. The core behavior is front-loaded, followed immediately by the clarifying negative case.

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 one-parameter read-style finder, the description covers what it returns conceptually, what it excludes, and why. The only gap is the absence of output shape details, especially since there is no output schema, which prevents a 5.

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 100% and the mailbox parameter already has a detailed schema description, including a pointer to list_authorized_mailboxes. The tool description adds no parameter-level detail, so baseline 3 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 names a specific action and resource: 'Find folders that share a name within the same parent.' It also distinguishes itself from find_duplicate_gmail_labels (different resource) and makes the intent explicit with 'likely duplicates worth merging.'

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?

It gives clear context for when to use the tool and explicitly states the exclusion: folders with the same name under different parents are not reported. However, it doesn't name alternative tools such as list_mail_folders or the follow-up merge_mail_folders, so it stops short of full routing 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?

No annotations are provided, so the description carries the burden. It adds a meaningful behavioral guarantee—returns times only, never event titles—but it does not disclose auth/permission needs, timezone assumptions, or what happens when no time range is supplied.

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 with the core behavior first and the privacy-relevant limitation second. Every clause earns its place; no filler or duplicated schema 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?

Reasonable for a simple query tool: it states the result type, multi-calendar scope, and privacy guarantee. However, with no output schema and no annotations, it should say more about required/optional time bounds and the shape of the returned busy blocks to be fully self-sufficient.

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 only 50%: mailbox and calendarIds are documented, but timeMin and timeMax have no descriptions. The description reinforces the multi-calendar behavior and output concept but does not explain the time-range parameters or their format, so it does not compensate for the 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?

States a specific action and scope: returning busy blocks across one or more Google Calendars to enable proposing a free slot. The explicit 'never event titles' distinguishes it from event-listing/search tools, and the Google-specific naming separates it from the Outlook variant.

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?

Gives clear context for when it is useful: when proposing a free slot. It does not explicitly name alternatives or exclusions, but the purpose and privacy constraint make the intended scenario unmistakable.

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?

Discloses the key limitation that it returns only times and never event titles, which is useful. However, with no annotations, it doesn't mention authentication, rate limits, or whether it returns only busy blocks (it implies busy blocks but doesn't clarify). It provides some behavioral context but not comprehensive.

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 sentences, front-loaded with the core purpose, no wasted words. The structure is efficient and immediately conveys the tool's function and a key constraint.

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 4 parameters, no output schema, and no annotations, the description is too sparse. It omits parameter semantics, usage guidance, and deeper behavioral details like time format or calendar selection. An agent would be under-informed to call 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 coverage is only 25% (only mailbox has a description). The tool description adds nothing about timeMax, timeMin, or calendarId parameters. Since coverage is low, the description should compensate, but it doesn't, leaving three parameters undefined.

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?

States the specific function: returning busy blocks on a calendar so a free slot can be proposed. It explicitly differentiates from event listing by noting 'Returns times only, never event titles,' which distinguishes it from list/search calendar event tools. The platform is clear from the tool name, though the description is generic.

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 versus alternatives like find_google_calendar_busy_times or list_outlook_calendar_events. It doesn't mention prerequisites, exclusions, or conditions that would select this tool over 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 carries the full behavioral burden. It clearly discloses that this is a read-only operation ('Read... without reading cells') and describes what is returned (worksheets and occupied ranges). It doesn't detail output shape or hidden-sheet handling, but it gives enough clarity about scope and safety.

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 sentences, front-loaded with the core purpose and immediately followed by actionable guidance. Every sentence earns its place, with zero redundant phrasing.

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?

There is no output schema, so the description must convey return value semantics, which it does at a high level (worksheets and occupied ranges). It is sufficient for the intended 'discover then read' workflow, though a bit more detail about the return format would make it fully 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?

Schema description coverage is 50%: mailbox is well documented in the schema, but workbookId has no description at all. The tool description implies workbookId refers to the target workbook but does not explain how to obtain it (e.g., from list_excel_workbooks). The description adds only minimal value for the undocumented parameter.

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 and resource ('Read a workbook's shape') and distinguishes it from cell-reading tools by explicitly saying 'without reading cells'. It also clarifies the deliverable: worksheets and their occupied ranges, which sets it apart from list_excel_workbooks (which lists workbooks) and read_excel_range (which reads cells).

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 gives explicit workflow guidance: 'Call this first to learn what sheets exist and how far the data reaches, then read from the one you want.' This clearly establishes when to use it, though it does not name a specific alternative tool (e.g., read_excel_range) or state when NOT to use 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?

With no annotations provided, the description carries the full burden and does add a behavioral trait: 'HTML-only messages are converted to plain text.' It also clarifies the decoded body and attachment metadata. However, it does not mention side effects (e.g., whether reading marks as read), auth specifics, or error behavior, so transparency is moderate.

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?

Three sentences with no filler. The first sentence front-loads the primary purpose and scope, the second adds a key transformation behavior, and the third provides the ID-source workflow. Every sentence earns its place.

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 read tool with no output schema and no annotations, the description covers the essential return values (decoded body, attachment name/type/size/attachmentId), the HTML conversion behavior, and how to obtain the messageId. It lacks an exact response structure and error conditions, but an agent has enough to invoke and interpret the result.

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 67%: mailbox and maxChars have descriptions, messageId does not. The description partially compensates by stating 'Get the message ID from search_gmail_messages,' giving provenance for the undocumented parameter. It also clarifies the attachmentId output that sibling tools consume, adding meaning beyond the raw 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 states a specific verb ('Read'), a resource ('one message'), and scope ('in full', including decoded body and attachment metadata). This clearly distinguishes it from nearby siblings like search_gmail_messages and get_gmail_thread, and the title 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 gives useful workflow context: 'Get the message ID from search_gmail_messages' and it names the downstream attachment tools that consume the returned attachmentId. It does not explicitly state when-not-to-use or list alternatives (e.g., get_gmail_thread), but the read-one-message use case is clear.

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. It discloses that bodies are decoded and messages are ordered oldest first, and implies a read-only operation. It does not mention potential side effects, but as a read tool that is acceptable. It omits details like pagination or error behavior, but these are not critical for a thread read. The provided behavioral details (decoded bodies, ordering) add real value 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?

Three concise sentences with no fluff. The first sentence states the core purpose and key details, the second gives usage guidance, the third provides a parameter sourcing hint. Information is front-loaded and every sentence earns its place.

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 a read operation with no output schema. The description explains what it returns (every message, decoded bodies, oldest first) and how to obtain the thread ID. It does not describe the exact return structure or mention large-payload handling, but for a straightforward thread read this is adequate. It covers the essential information an agent needs to call 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 coverage is 67% (2 of 3 parameters have descriptions). The threadId parameter lacks a schema description, but the tool description compensates by stating 'Get the thread ID from search_gmail_messages.' This is essential guidance. The other parameters are already documented in the schema, and the description adds context on how to use threadId effectively. Overall, the description adds meaningful parameter semantics 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 ('Read every message in a conversation'), the resource (a Gmail thread), and specific details (oldest first, decoded bodies). It also distinguishes from the sibling get_gmail_message by explicitly saying 'Use this instead of repeated get_gmail_message calls when you need the whole exchange', making it unambiguous which tool to pick.

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 when-to-use guidance: 'Use this instead of repeated get_gmail_message calls when you need the whole exchange.' It also tells the agent how to obtain a required parameter: 'Get the thread ID from search_gmail_messages.' This is clear, actionable, and leaves no ambiguity about 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 carries the burden. It states 'Read' indicating a non-mutating operation, but does not disclose other behaviors like authentication requirements, rate limits, or the exact scope of 'in full' beyond guest list. It adds some transparency but leaves 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?

A single, front-loaded sentence with no redundancy. It efficiently conveys the core purpose and unique detail (guest list) without waste.

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 get operation, the description is fairly complete in stating what is returned (full event, guest list). However, it omits parameter clarifications (especially calendarId) and there is no output schema to fill the gap, leaving some ambiguity about required identifiers.

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 only 33% (only mailbox has a description). The description does not explain eventId or calendarId at all. It implicitly identifies eventId as the event identifier but provides no additional semantics, failing to compensate for low 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 action: 'Read one event in full', including guest list details. It distinguishes from listing/searching by emphasizing a single event and full details, though it doesn't explicitly name sibling 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 implies when to use it (when full details of one event are needed) but does not explicitly contrast with alternatives like list_google_calendar_events or search_google_calendar_events, nor provide exclusion criteria.

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 clearly states it reads without reading cells, signaling a non-destructive structural read, and discloses the returned data (tabs, sizes, named ranges). This is sufficient transparency for a read-only 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?

Two sentences with no filler. Purpose and usage are front-loaded, and every word contributes to understanding. The structure is optimal for the 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?

Given the tool's simplicity (2 params, no output schema), the description covers the core use case and expected output. It could mention error conditions or limits, but for a structural read operation, it is adequate and distinct from siblings.

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 mailbox parameter is well-described in the schema, but spreadsheetId has no description. The tool description adds context about the output (structure) but doesn't elaborate on spreadsheetId semantics or format. Since schema coverage is only 50%, the description should compensate, but it mostly relies on the parameter name.

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 ('Read') and resource ('spreadsheet's shape') with concrete elements: tabs, sizes, and named ranges. It explicitly contrasts with reading cells and ties to a subsequent read-range action, clearly distinguishing it from read_google_sheet_range and list_google_spreadsheets.

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 gives explicit guidance: 'Call this first to learn what tabs exist, then read a range from the one you want.' This provides a strong when-to-use instruction relative to read operations. It doesn't explicitly list alternatives or exclusions, but the sequencing advice is clear enough to steer an agent.

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 burden of explaining behavior. It discloses that the response includes full detail, notes, and any parent task, which is useful, but it does not mention failure modes, permissions, or whether the operation is read-only.

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 that is front-loaded with the core purpose and adds the key distinguishing details (notes and parent task). There is no redundant or filler 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 getter, the description gives a reasonable overview of the return value, but without an output schema or parameter guidance, an agent may not know what fields to expect or how to obtain valid listId/taskId values. It is adequate but leaves clear 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 coverage is only 33%; only mailbox is described. The description does not explain listId or taskId, and it does not compensate for the missing parameter documentation. The parameter names are somewhat self-explanatory, but no additional meaning is added.

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 full detail for a single task, including notes and parent task. This distinguishes it from list_google_tasks, which returns multiple tasks, though it does not explicitly name sibling alternatives.

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 list_google_tasks or get_outlook_task. The phrase 'one task' implies a retrieval use case, but no prerequisites, exclusions, or alternative routing 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 provided, the description carries the behavioral disclosure burden. 'Read' clearly signals a non-mutating operation, and it adds useful return-content context: a full event including guest addresses and their acceptance status. It does not discuss error behavior or authorization, but for a simple read tool the core behavior is transparent.

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 that front-loads the action and scope, then adds the valuable guest-list detail. There is no filler, repetition of the title, or irrelevant 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?

For a two-parameter read tool, the description is largely sufficient: it states what is returned, signals read-only behavior, and relies on the schema for mailbox documentation. The main gap is that eventId provenance is not explained, but given the tool's simplicity this is a minor omission.

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 50%. The mailbox parameter is documented in the schema, but eventId is only typed as a string with no explanation. The description does not explain what eventId should be, how to obtain it, or that it likely comes from a previous list or search call, so it fails to compensate for the missing 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 opens with 'Read one event in full', identifying a specific verb and resource, and adds the distinctive detail that the guest list, each guest's address, and acceptance status are returned. This clearly separates it from list/search siblings that deal with multiple events or summaries.

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 'one event in full' implies it should be used when a single known event's complete details are needed, rather than for listing or searching. However, the description does not explicitly name alternatives like list_outlook_calendar_events or search_outlook_calendar_events, nor does it state when not to use 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 behavioral burden. It discloses the read-only nature ('Read'), the ordering, and that bodies are included. However, it does not mention potential limitations such as message size, truncation, or whether the operation marks messages as read. For a read tool, the core behavior is transparent, but a note on large conversation handling would be beneficial.

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?

Three short sentences with zero redundancy. The main function is front-loaded, followed by usage guidance and a prerequisite. Every sentence earns its place, and the description 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?

Given the lack of an output schema, the description does not describe the return format (e.g., structure of messages, fields, pagination). It also omits any caveats about performance or size for large conversations. While the core purpose is clear, an agent might need more detail on what the response contains. This is a moderate gap for a tool that reads multiple messages.

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 67% (mailbox and maxCharsPerMessage have descriptions; conversationId does not). The description compensates for the undocumented conversationId by explicitly stating 'Get the conversationId from search_outlook_messages', adding practical meaning. It also implies the purpose of maxCharsPerMessage through context (body budget), though the schema already covers that. This adds value beyond the schema for the key parameter.

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 ('Read'), a specific resource ('every message in a conversation'), and adds ordering ('oldest first') and content ('with bodies'). It explicitly distinguishes itself from get_outlook_message and references search_outlook_messages, making the tool's purpose unambiguous and distinct from 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 gives clear usage guidance: use this instead of repeated get_outlook_message calls when the whole exchange is needed. It also tells the agent where to obtain the conversationId (from search_outlook_messages), providing a prerequisite and alternative. No ambiguity remains about when to choose this tool.

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