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

With no annotations provided, the description carries full burden and successfully discloses critical behavioral traits: partial irreversibility ('Emails already moved will not be returned to source') and side effects (enabling new operations). It does not, however, clarify the final state of the abandoned operation or permission requirements.

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

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

Three sentences with zero waste: first establishes purpose, second provides usage constraint, third discloses irreversibility consequence. Information is front-loaded and each 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 zero-parameter mutation tool with no output schema, the description covers essential safety warnings regarding data loss. It could be improved by clarifying the post-abandonment state visible to get_move_status, but adequately covers the critical user-facing consequence.

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

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

The input schema contains zero parameters (empty object). Per rubric guidelines, zero-parameter tools receive a baseline score of 4. The description appropriately makes no parameter claims, matching the schema structure.

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

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

The description clearly specifies the verb (abandon), resource (in-progress move operation), and outcome (so a new one can start). It effectively distinguishes from sibling move operations (bulk_move, move_email) which initiate moves rather than aborting 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?

Provides explicit safety constraint: 'Only use if you are certain the operation should not be resumed.' This establishes when-not-to-use versus attempting to resume. However, it omits explicit reference to get_move_status as the logical prerequisite for verifying move state before abandonment.

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. Explains the 'copy-verify-delete pipeline' safety mechanism and dryRun preview capability. Missing: error handling behavior, confirmation of whether source emails are deleted after copy, rate limits, or idempotency guarantees expected for mutation tools.

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: purpose statement, safety pipeline disclosure, and usage tip. Front-loaded with specific operation details; every clause 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?

Appropriate for a 4-parameter mutation tool with no output schema. Covers the safety semantics (crucial for a 'move' operation) and preview capability. Could improve by clarifying the destructive aspect of the source deletion or referencing the default INBOX behavior mentioned in 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 100%, establishing baseline 3. Description adds value by framing dryRun as a 'preview' usage pattern and contextualizing 'N days' within the archiving workflow. Connects the 'targetMailbox' parameter to the archive folder concept explicitly.

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?

Specific verb ('move') with clear resource ('emails'), condition ('older than N days'), and endpoints ('source mailbox' to 'archive folder'). The 'archive' semantic distinguishes it from sibling delete_older_than and general bulk_move 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 guidance to 'Use dryRun: true to preview' and references implementation similarity to bulk_move. However, lacks explicit when-to-use vs destructive alternatives like delete_older_than or simple move_email given the large sibling tool set.

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 never states whether the batch is atomic, what happens if one event in the array is invalid, whether partial successes are possible, or what identifiers are returned. The dryRun behavior is documented in the schema, not the description, so it earns no credit here.

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, front-loaded with the verb+resource and the scope, with every sentence carrying distinct information (what, why, field shape). No filler.

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 should cover failure semantics and return expectations; it covers neither. The schema's dryRun flag partially mitigates this, but the agent still can't tell whether a mid-array failure aborts the whole call.

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 calendarId, events, dryRun and the per-event field list. The description's note that each array item uses the same fields as create_event adds a useful cross-reference, but the baseline of 3 applies when 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?

States a specific verb (create) and resource (calendar events), with the 'multiple in one call' scope made explicit. It explicitly distinguishes itself from the sibling create_event by naming it as the repeated-call 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?

Gives a clear condition for choosing this tool: use it instead of calling create_event repeatedly when creating several events. There are no explicit when-not-to-use cases (e.g. single event, cross-calendar batches), so it falls short of 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?

Crucially, it discloses internal operational mechanics not found in the schema, specifically that it 'Processes in chunks of 500 with per-chunk timeouts for reliability.' This provides the agent with essential information about the tool's execution flow and fault tolerance.

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 highly concise, dedicating minimal space to state the core function, the operational safeguards (chunking/timeouts), and the required safety mechanism (dryRun).

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 complexity (13 filters) and the lack of output schema, the description is highly complete. It covers how the operation works, how it's secured (dryRun), and how it handles large volumes (chunking/timeouts).

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

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

The input schema coverage is 100%, setting a baseline of 3. The description does not elaborate on the semantics of the 13 specific filters (e.g., how `smaller` interacts with `larger`) beyond stating that they can be used in combination.

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 deletes emails and emphasizes its ability to process 'any combination of filters,' distinguishing it from simple single-item deletion siblings. It is clear in its function as a bulk deletion utility.

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 a critical usage guideline by advising the agent to 'Use dryRun: true' when previewing changes. This operational advice is vital for minimizing risk, especially for a tool with high-impact parameters.

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

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

No annotations are provided, so the description must carry the full behavioral burden. 'Delete' implies a destructive, likely irreversible mutation, but the description does not disclose whether the deletion is permanent, whether it spans all mailboxes or only the default INBOX, permissions required, or the existence of a dry-run option. This is a significant gap for a destructive bulk operation.

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

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

The description is a single, front-loaded sentence with no filler. While extremely terse, it is not wasted or redundant; it simply lacks the additional context that the other dimensions penalize. Structurally it is clean and 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 destructive bulk-delete tool with no annotations and no output schema, the description is substantially incomplete. It omits critical behavioral context such as permanence, scope (e.g., mailbox vs. all mailboxes), and confirmation requirements. Schema coverage handles parameters, but the description fails to complete the behavioral picture.

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 all three parameters (sender, mailbox, dryRun) are already documented in the schema. The description adds nothing beyond what the schema provides—'specific sender' merely restates the sender parameter—so the baseline score of 3 applies.

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

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

The description states a specific verb and resource: 'Delete all emails from a specific sender.' This clearly identifies both the action (bulk delete) and the filter (sender), distinguishing it from broad deletion tools like delete_email or bulk_delete. However, it does not differentiate from close siblings such as bulk_delete_by_subject or delete_older_than, so it stops short of a 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 description provides no guidance on when to use this tool versus alternatives such as bulk_delete, bulk_delete_by_subject, delete_email, or delete_older_than. There are no stated prerequisites, exclusions, or context cues to help an agent choose this over other deletion tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that deletion is destructive and likely irreversible, whether messages go to trash, whether the dryRun parameter is honored, or what permissions or scope limits apply. The phrase 'all emails matching' gives only minimal scope context.

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

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

The description is a single front-loaded sentence with no wasted words. However, its brevity comes at the cost of omitting important operational details, making it under-specified rather than optimally concise for a destructive bulk 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?

Given that this is a destructive bulk-delete tool with no annotations, no output schema, and no mention of dryRun or irreversibility, the description is not complete enough for safe invocation. It leaves the agent without critical context about side effects, reversibility, and the safety mechanism available in 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 description coverage is 100%, so the schema already documents all three parameters including the dryRun safety behavior. The description adds only 'subject pattern' versus the schema's 'Subject keyword to match', which is marginal added meaning. Baseline 3 is appropriate when 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 ('Delete') and resource ('emails') plus a scoping condition ('matching a subject pattern'), which distinguishes it from sender-based siblings like bulk_delete_by_sender. However, it does not explicitly name those siblings or clarify how it differs from generic bulk_delete, so sibling differentiation is implied rather than explicit.

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 such as bulk_delete_by_sender, bulk_delete, or delete_email. It also omits any prerequisites, warnings, or conditions for safe use, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about the irreversible/destructive nature of deletion, required permissions, partial-failure behavior when some eventIds are invalid, or what a dryRun returns — all critical for a bulk destructive mutation.

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 the core action front-loaded and no wasted text. The second sentence is mildly promotional but does carry the differentiation from delete_event.

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 parameters are fully covered by the schema and no output schema exists, so return values need no explanation. Still, for a bulk destructive tool with zero annotations, the description omits safety-critical context (irreversibility, partial failures) that an agent should know before invoking it.

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

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

Schema description coverage is 100%, and the dryRun, eventIds, and calendarId parameters are all documented in the schema itself. The description adds no syntax, format, or constraint details beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb ('Delete') and resource ('calendar events') with a clear scope qualifier ('multiple ... in one call'). It also names the sibling delete_event, distinguishing itself from the single-item variant, though the distinction is framed as efficiency rather than a semantic difference.

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?

'Much more efficient than calling delete_event repeatedly' implies the tool is for bulk/multi-event deletion rather than a single event. However, it offers no explicit when-to-use/when-not guidance or prerequisites, leaving the agent to infer selection criteria from the sibling name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about mutation risk, reversibility, auth/account requirements, or rate limits. The only useful caveat (client-side BODYSTRUCTURE scan, 500-email limit) lives in the schema, not the description.

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 zero filler. It is arguably under-specified for a 13-parameter destructive tool, but on pure conciseness and structure it is 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 13-parameter bulk mutation with no annotations and no output schema, the description omits the dry-run-first workflow, the fact that at least one filter should accompany hasAttachment, and what the operation reports back. An agent would have to infer these from the schema alone.

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 every parameter is already documented in the schema, including the dryRun preview semantics and the hasAttachment constraint. The one-line description adds no syntax or format meaning beyond that, so the baseline 3 applies.

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

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

Specific verb pair (flag/unflag) plus resource (emails) and scope (bulk, any filter combination) — an agent can distinguish it from flag_email (single) and bulk_flag_by_sender (sender-only). It doesn't name those siblings explicitly, but the scope wording differentiates it functionally.

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?

'In bulk' and 'any combination of filters' imply when this is preferable to flag_email, and the schema's dryRun parameter hints at a safe preview workflow. However, there is no explicit when-to-use vs. bulk_flag_by_sender guidance and no exclusions or prerequisites 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 burden yet only restates the mutation. It does not disclose that flagging is reversible, whether it spans mailboxes, permission/auth requirements, or the existence of the dryRun safety path (which is left to the schema alone). Thin for a bulk 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?

A single front-loaded sentence with zero redundancy. The core scope ('all emails from a specific sender') is stated up front with no filler.

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 bulk mutation with no annotations and no output schema, the description should convey more about impact, reversibility, or scope (e.g., which mailbox, what a run returns). The schema covers the parameters, but the behavioral context an agent needs to call this safely 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 description coverage is 100%, so the schema already documents sender, flagged, mailbox, and dryRun. The description adds no format, default, or edge-case detail beyond what the schema provides; baseline 3 applies.

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

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

The description uses a specific verb pair (flag/unflag) plus a precise scope ('all emails from a specific sender'), clearly distinguishing it from single-target flag_email and generic bulk_flag. An agent can identify the operation and its bulk-by-sender semantics without opening the schema.

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

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

Usage is implied by the bulk 'by sender' scoping, but there is no explicit when-to-use, when-not-to-use, or named alternative (e.g., bulk_flag for specific IDs vs this for whole-sender sweeps). Nothing tells the agent which of the many bulk_* siblings to prefer.

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 and mostly doesn't: it never states that this is a mutating write, that it can affect the whole account (not just INBOX), whether it's reversible, or what permissions/auth are needed. 'Optionally filtered by sender' is the only scope qualifier offered for what is potentially a mass state change.

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 tight sentence with the operation front-loaded and the qualifier trailing it; nothing is wasted and there is no filler.

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 bulk operation with no annotations and no output schema, the description is only minimally complete: it omits the account-wide scope, reversibility, and any pointer to the single-message alternative. Schema coverage compensates for parameters, but behavioral context for a bulk mutation is thin.

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 dryRun, sender, and mailbox are already documented in the schema with their defaults and semantics. The description's 'optionally filtered by sender' only restates what the schema says, adding no syntax or format detail beyond it, so the 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 specific verb+resource ('Mark all emails as read') plus the optional sender filter, so the operation is unmistakable. It does not differentiate itself from close siblings such as mark_as_read (single message) or bulk_mark_unread, leaving the agent to infer the bulk/scope distinction on its own.

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 when-to-use guidance, no scenario in which this beats mark_as_read or mark_older_than_read, and no mention of opting into the safe dryRun path even though that parameter exists. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses that the operation affects 'all emails' and can be filtered by sender, but it does not mention the dryRun safety option, permission requirements, reversibility, or the impact of marking an entire mailbox unread.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the action and the optional filter, making it quick for an agent to parse.

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

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

The purpose and filter are covered, and the schema fully documents the parameters, so an agent has enough to invoke it. However, for a bulk mutation tool with no annotations and no output schema, the description omits relevant context such as dryRun usage and expected return behavior.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters in detail. The description only echoes the sender filter and adds no new semantic detail about dryRun or mailbox behavior, which is the expected baseline when 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 ('Mark all emails as unread') and includes the optional sender filter. It is clear what the tool does, though it does not explicitly distinguish itself from the opposite operation, bulk_mark_read, or the singular mark_as_read.

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

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

The description implies this is a bulk operation and mentions the optional sender filter, giving some usage context. However, it does not state when to choose this over bulk_mark_read or mark_as_read, nor does it mention exclusions or preconditions.

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 disclosure burden. It excellently documents the safety mechanism ('safe copy-verify-delete with fingerprint verification and a persistent manifest') and idempotency characteristics, critical for a destructive move operation. However, it omits potential rate limits, error handling behavior, or confirmation that source emails are deleted after verification.

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 efficiently structured: purpose statement, safety mechanism disclosure, and usage guidance. Every sentence earns its place with zero redundancy or filler. Technical details (fingerprint verification, persistent manifest) are packed concisely without sacrificing 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 complex 15-parameter destructive operation with no output schema, the description adequately covers the mechanism and safety but leaves gaps regarding return value structure (only hinting at a 'manifest'), success/failure indicators, and specific warnings about the hasAttachment constraint documented in the schema. Functional but not comprehensive.

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?

Input schema has 100% description coverage, establishing a baseline of 3. The description adds the concept of 'any combination of filters' which reinforces how the multiple filter parameters interact, and explicitly highlights the dryRun parameter's utility, but does not elaborate on specific parameter formats (e.g., date formats) or constraints 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 explicitly states 'Move emails matching any combination of filters from one mailbox to another', providing a specific verb, resource, and scope. The phrase 'any combination of filters' effectively distinguishes this tool from siblings like bulk_move_by_sender or bulk_move_by_domain which likely support limited filter types, and from move_email which likely handles single emails.

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 valuable safety guidance with 'Use dryRun: true to preview without making changes', but lacks explicit guidance on when to use this general-purpose filterable version versus the specialized bulk_move_by_sender/bulk_move_by_domain variants. No prerequisites or exclusion criteria are mentioned.

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

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

No annotations are provided, so the description carries the full burden. While 'Move' implies a write operation, the description fails to disclose critical behavioral traits for a bulk operation: whether moves are reversible, what the dryRun behavior returns, success/failure handling, or performance implications of large batches.

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 waste: first sentence establishes core function, second establishes architectural relationship to sibling tool. 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?

Given the lack of annotations and output schema, the description is minimally adequate for a 4-parameter tool, but lacks important context for a bulk mutation operation (e.g., return value description, safety warnings). It meets baseline requirements but has 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 description coverage is 100%, so parameters are well-documented in the schema itself. The description adds context that this is a 'wrapper' which helps understand the domain parameter's filtering role, but does not add syntax details, format constraints, or examples beyond what the schema 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?

Description clearly states the specific action (move), resource (emails), scope (from a specific domain to a folder), and explicitly identifies itself as a 'convenience wrapper around bulk_move with a domain filter,' effectively distinguishing it from the general bulk_move sibling.

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

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

The 'convenience wrapper' statement implies this tool is for domain-specific filtering versus the general bulk_move, providing implicit context. However, it lacks explicit when-to-use guidance compared to siblings like bulk_move_by_sender or warnings about irreversible operations.

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 but only minimally discloses the bulk nature ('all emails'). It fails to mention the dryRun safety feature (present in schema), reversibility concerns, partial failure behavior, or performance implications of bulk operations.

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?

Single sentence is front-loaded and efficient with no wasted words. However, extreme brevity contributes to missing critical behavioral and usage context that would require additional sentences.

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 bulk mutation tool with no annotations and no output schema, the description is inadequate. It fails to describe return values (success count? moved message IDs?), error conditions, or the dryRun preview capability, leaving agents uncertain about invocation outcomes.

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%, documenting all four parameters including dryRun and sourceMailbox defaults. The description implies usage of sender and folder but does not add syntax guidance or validation rules beyond the schema, warranting the baseline score.

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 provides a specific verb ('Move'), clear resource ('all emails from a specific sender'), and distinguishes from siblings by specifying the 'by sender' filtering mechanism (differentiating it from bulk_move, bulk_move_by_domain, and move_email).

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

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

No guidance provided on when to use this tool versus alternatives like bulk_move (general query-based moving), move_email (single item), or bulk_move_by_domain. Does not mention prerequisites or 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose meaningful semantics ('only the fields to change'), clarifying this is a partial/patch update, but it is silent on atomicity, what happens if one eventId fails mid-batch, permissions, and it never surfaces the dryRun behavior that the schema describes.

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 tightly scoped sentences with zero waste, and the core purpose is front-loaded ahead of the structural constraint. Nothing is padded or redundant.

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 bulk mutation with no annotations and no output schema, the description covers what an agent needs to construct a correct call (eventId required, only changed fields). It drops the dryRun capability and any batch-failure semantics, leaving minor 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 description coverage is 100%, so the schema already documents calendarId, dryRun, and the update fields. The description reinforces the eventId requirement and partial-update semantics, adding modest value, but introduces no format or syntax detail beyond the schema. 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 specific verb ('Update') and resource ('multiple calendar events') with the batch scope made explicit via 'in one call,' which distinguishes it from the singular update_event sibling. It does not name update_event or the other bulk_* event siblings directly, so it stops short of full sibling differentiation.

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

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

The phrase 'multiple ... in one call' implies the batch use case versus single-event updates, but the description never states when to prefer this over update_event, nor any exclusions or prerequisites. Usage is implied rather than spelled out.

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. For a mutation tool it says nothing about whether completion is reversible, whether it is idempotent, what happens with an invalid reminderId, or whether permissions are required. It reveals only the state transition itself, which the name already implies.

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 short sentence with no wasted words, and the action is front-loaded. It is perhaps too terse to be maximally useful, but nothing is redundant or padded.

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?

This is a mutation with no annotations and no output schema, so the description should carry behavioral and result context. It omits reversibility, error behavior, and what the agent can expect back, leaving the definition under-specified for a write operation.

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

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

Schema description coverage is 100%, so both parameters (listName, reminderId) are already documented by the schema. The description adds no format, casing, or ID-sourcing detail beyond what the structured fields provide, making 3 the correct baseline.

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 and resource ('Mark a reminder as completed') and scopes it to iCloud Reminders, so the agent knows the target domain. It does not explicitly distinguish itself from update_reminder, which could plausibly perform the same state change, but the verb+resource pairing is unambiguous on its face.

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 versus update_reminder, delete_reminder, or get_reminder. The only implied usage is that the reminder must already exist in the named list, and no prerequisites or exclusions are 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 provided, the description carries the full burden. It discloses the From address constraint and multipart format behavior, but fails to mention that this is an irreversible external action (sending email), potential rate limits, or error handling. Critical safety context for a destructive-by-nature operation is missing.

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 waste. First sentence establishes core function and transport mechanism; second covers sender constraint and format support. Every clause provides essential information not redundant with structured fields.

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 7-parameter email sending tool with no output schema and no annotations, the description covers format options and sender identity but omits discussion of delivery status, failure modes, or irreversibility. Adequate but lacks critical behavioral warnings expected for external-communication 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 has 100% coverage (baseline 3). The description adds value by explaining the implicit From constraint (not in schema) and summarizing the body/html multipart relationship. It clarifies that body serves as fallback when html is provided, adding semantic context beyond individual field 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?

Description clearly states 'Compose and send a new email via iCloud SMTP' - specific verbs (compose, send), resource (email), and mechanism (iCloud SMTP). It distinguishes from sibling tools like reply_to_email and forward_email by specifying 'new email' and the SMTP transport method.

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 through 'new email' but does not explicitly state when to use this versus similar siblings like reply_to_email or forward_email. No explicit 'when-not-to-use' or alternatives are named, though the tool name provides strong implicit 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 successfully communicates the non-destructive/safe nature ('without moving or deleting'), which is critical given the sibling context. However, it lacks disclosure of return value format, rate limits, or performance characteristics beyond the hasAttachment constraint buried in the schema.

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

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

Two sentences with zero waste. First sentence front-loads the core action and safety guarantee; second sentence provides workflow context. 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?

Despite 12 parameters and no output schema, the description omits what the tool returns (a number? an object?). The hasAttachment parameter has a critical 500-email limit constraint documented only in the schema. Adequate but has clear gaps regarding return value and high-impact parameter constraints.

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% with 12 well-documented filter parameters. The description references 'a set of filters' acknowledging the filtering capability without redundant enumeration. Baseline 3 is appropriate since schema carries the full semantic load.

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?

Specific verb 'Count' with resource 'emails' and explicit scope 'without moving or deleting them'. Clearly distinguishes from destructive sibling tools like bulk_move and bulk_delete by contrasting its non-destructive nature.

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 states 'Use this before bulk_move or bulk_delete to preview how many emails will be affected', providing clear workflow guidance and indicating when to prefer this tool over immediate destructive actions.

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 usefully discloses the name-collision failure mode, which the schema does not, but says nothing about permissions/authentication requirements, side effects on existing calendars, or what the call returns. Adequate but thin for a mutation tool with zero annotation coverage.

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, zero filler, with the core action front-loaded and the failure condition following. Nothing in the text is redundant or restated from the 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 single-parameter creation tool with no output schema and no nested objects, the description covers what it creates and the one error case an agent must anticipate. It stops short of describing the returned handle/identifier for the new calendar, which would be the remaining useful 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?

There is one parameter and schema description coverage is 100% ('Name of the new calendar'), so the schema already does the parameter work. The description adds no extra constraints on the name (length, uniqueness scope, allowed characters) beyond the failure note, so the baseline 3 applies.

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

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

States a specific verb (Create) and a precisely-named resource (a new event calendar in iCloud Calendar). The noun 'calendar' cleanly separates it from create_event, bulk_create_events, and create_reminder_list among the siblings, so an agent can route to it without opening any schema.

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

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

Usage is implied by the verb and the domain rather than stated: no explicit when-to-use guidance, no comparison to create_event or bulk_create_events for creating multiple calendars. The precondition 'Fails if a calendar with that name already exists' does give a usable constraint before calling, which lifts it above a bare 2.

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. 'Create' implies a write operation, but description omits duplicate handling, return value (no output schema exists), idempotency, or whether partial failures are possible. Lacks disclosure of iCloud-specific behaviors.

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?

Extremely brief at six words. While not verbose, the extreme brevity contributes to under-specification given the tool's complexity. No filler content, but misses critical context that would earn a 5.

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?

Inadequate for a 12-parameter mutation tool with zero required fields (unusual design) and no output schema. Description fails to explain what constitutes a valid minimal contact or what the operation returns, leaving significant agent uncertainty.

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 parameters are fully documented in the schema. Description adds no supplemental parameter guidance (e.g., precedence between 'fullName' vs 'firstName+lastName'), warranting the baseline score 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?

States specific verb 'Create' and resource 'contact' with scope 'iCloud Contacts'. However, it does not explicitly distinguish from sibling tool 'update_contact' (e.g., clarifying this is for new records only).

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 no guidance on when to use this versus 'update_contact' or 'search_contacts'. Fails to mention the unusual 'all parameters optional' constraint, which is critical for an agent to understand minimum viable input.

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 the iCloud domain and all-day event behavior, but omits safety details (idempotency, validation errors), authorization requirements, and what the tool returns upon success.

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 waste: first establishes purpose, second delivers critical implementation detail for all-day events. Appropriately front-loaded and dense with actionable 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 an 11-parameter creation tool with no output schema or annotations, the description covers the essential use case but leaves gaps regarding return values, error conditions, timezone handling behavior, and integration with list_calendars.

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?

Despite 100% schema description coverage, the description adds value by explicitly linking the allDay flag to the YYYY-MM-DD format requirement ('use allDay:true and YYYY-MM-DD'), reinforcing the parameter interaction imperatively.

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 specific action ('Create a new event') and target resource ('iCloud calendar'), distinguishing it from sibling tools like update_event, delete_event, and email-related functions.

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 specific syntax guidance for all-day events ('use allDay:true and YYYY-MM-DD'), but lacks broader guidance on when to use this versus suggest_event_from_email or prerequisites like obtaining calendarId from list_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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to mention critical mutation behaviors: whether the operation is idempotent, if nested mailbox paths are supported, what happens if the name already exists, or what the return value indicates.

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

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

The description is extremely brief at only four words, containing no redundancy or filler. However, given the lack of annotations and behavioral context, it borders on under-specification rather than optimal conciseness.

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

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

For a single-parameter creation tool without an output schema, the description meets minimum viability by identifying the operation type. However, given zero annotation coverage, it should explicitly address folder nesting capabilities and uniqueness constraints to be 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?

With 100% schema description coverage, the 'name' parameter is already well-documented as 'Name of the new mailbox'. The description adds no additional semantic context (e.g., naming restrictions, path separators for nesting), but the baseline score of 3 is appropriate given the schema's completeness.

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 ('Create') and identifies the resource ('mailbox/folder'), clarifying that this refers to email folders rather than user accounts. However, it does not explicitly differentiate from sibling operations like 'rename_mailbox' or 'delete_mailbox', nor does it specify scope constraints (e.g., parent mailbox context).

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites (such as checking for existing mailboxes via 'list_mailboxes'), or error handling scenarios (e.g., duplicate names).

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 not disclose whether the target list must pre-exist, what happens to duplicate titles, whether defaults are applied, or what is returned; 'Create' implies mutation with no further 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?

A single, front-loaded sentence with no filler or redundancy. It is appropriately terse for the resource, though the brevity borders on under-specification rather than earned conciseness.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin: it omits prerequisites, return behavior (e.g., a reminder ID needed for complete_reminder), and any interaction with list state. The agent lacks enough to invoke 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 100%, with each parameter documented (title, listName, due, notes, priority) in the schema itself. The description adds no extra param meaning, so the baseline of 3 applies.

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

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

States a specific verb (Create) and resource (reminder in iCloud Reminders), clearly distinct from create_reminder_list and update_reminder. However, it does not explicitly differentiate itself from its close siblings, so it stops short of a 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 description gives no when-to-use guidance, no prerequisites (e.g., must the list already exist?), and no mention of alternatives like create_reminder_list or update_reminder. The agent must infer context entirely.

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 a real behavioral trait beyond the schema: the call fails if a list with that name already exists, making the operation non-idempotent on duplicates. However, it says nothing about permissions/account requirements, case sensitivity of the name match, or what is returned on success.

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 tight sentences with no filler, purpose front-loaded and the error precondition immediately after. Nothing is wasted.

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 create tool with no output schema and no annotations, the description covers what it does and the main failure mode. A brief note on the return value or name-matching rules 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 coverage is 100% and the single parameter has its own description ('Name of the new list'), so the schema already does the work. The description adds only that the name must be unique, a constraint rather than a semantic expansion of the parameter itself.

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

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

States a specific verb and resource ('Create a new Reminders list') and scopes it to 'iCloud Reminders', which separates it from create_calendar and create_reminder in the sibling list. It does not explicitly name the related rename_reminder_list/delete_reminder_list tools, so it falls short of full sibling differentiation.

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

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

The duplicate-name failure condition implies when the call will be rejected, but there is no explicit guidance on when to use this versus rename_reminder_list or list_reminder_lists (e.g., check first to avoid collisions). Usage 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?

With no annotations provided, the description carries the full burden. It successfully discloses the persistence model ('stored persistently') and execution lifecycle ('run on demand'). However, it fails to mention important behavioral traits: that rules perform real (potentially destructive) actions when run, what happens if a duplicate name is provided, or whether validation occurs immediately.

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 consists of two efficient sentences with zero waste. The first sentence front-loads the core purpose, while the second adds essential behavioral context about persistence and execution. 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?

Given the high complexity (nested filter/action objects) and 100% schema coverage, the description adequately explains the tool's purpose and persistence model. It appropriately omits return value documentation since no output schema exists. Minor gap: lacks warning about destructive actions (delete) that rules can perform when executed.

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%, establishing a baseline of 3. The description text implies the function of the 'filters' and 'action' parameters at a high level ('applies a specific action to emails matching a set of filters'), but does not add syntax details, format examples, or semantics 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 specific verb (Create), resource (saved rule), and mechanism (applies action to emails matching filters). It effectively distinguishes from sibling bulk_* tools by emphasizing that rules are 'saved' and 'stored persistently' rather than executing immediately.

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

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

The description provides clear context for when to use this tool (creating reusable automation) by stating rules 'can be run on demand or all at once with run_all_rules.' It explicitly references the sibling execution tool run_all_rules. However, it lacks explicit 'when-not-to-use' guidance contrasting with immediate bulk operations.

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

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

No annotations are provided, so the description carries the full burden. It discloses the hard guardrail (calendar must be empty, past and future events both count), the pointer to the tool that clears that blocker, and a scope exclusion. It does not state irreversibility, permission/auth requirements, or what the dryRun default is, which are meaningful gaps for an unannotated destructive 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, front-loaded with what it deletes, then the blocker and its workaround, then the exclusion. Every clause carries information an agent needs; nothing is padding.

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

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

For a tool with no annotations, no output schema, and zero required parameters, the description adequately covers scope, precondition, and alternative. It is slightly thin on the edge case of supplying neither or both identifiers, and does not describe the delete's result or permanence.

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 all three parameters are already documented, including the mutual-exclusivity note on calendarId ('use instead of name'). The description reinforces that identifiers must be exact but adds nothing about dryRun (e.g., default value or that it is the safe-preview flag), so baseline 3 applies.

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

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

States a specific verb and resource ('Delete an iCloud event calendar') plus the two identifiers it accepts (exact name or calendarId). It also implicitly separates itself from delete_event (calendars, not events) and delete_reminder_list ('Will not delete Reminders lists'), so an agent can route without opening sibling 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?

Gives an explicit precondition ('The calendar must have no events (past or future)') and names the remedial alternative tool ('delete them first with bulk_delete_events'). It also states an explicit when-not case by excluding Reminders lists, which is exactly the sibling an agent might otherwise confuse this with.

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 irreversibility via 'permanently', which is the most important trait for a destructive operation. However, it says nothing about required permissions, confirmation behavior, or how a missing/invalid contactId is handled.

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 the verb and permanence up front and zero filler. Nothing is wasted.

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 destructive tool with no annotations and no output schema, the description is only marginally complete: 'permanently' is useful, but it omits whether deletion is recoverable, what errors occur for a nonexistent contactId, and any confirmation flow. It is adequate but leaves clear gaps for a delete operation.

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

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

Schema description coverage is 100%, so both contactId and the dryRun safety flag are already documented in the schema, including that dryRun mutates nothing. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (delete) and resource (contact in iCloud Contacts) and adds a scope qualifier (permanently). The resource noun cleanly separates it from other delete_* siblings like delete_email, delete_event, and delete_reminder. It stops short of explicitly contrasting with update_contact or any bulk alternative, so it is clear but not sibling-differentiated by description text.

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 versus update_contact (to scrub fields) or any bulk cleanup path, and no prerequisite stated. The only usage signal is the implied one from the name itself.

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 behavioral burden. It states 'Delete' but does not disclose whether deletion is permanent, whether it moves to trash, whether a dryRun is available (despite the schema including one), or what permissions are required.

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 phrase with no wasted words. It is arguably under-specified, but the sentence itself is efficient and not 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 mutation tool with no annotations and no output schema, the description is too sparse. It omits critical context such as the effect of dryRun, default mailbox behavior, and irreversibility, leaving the agent with insufficient information to call the tool safely.

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 all parameters (uid, dryRun, mailbox) are documented in the input schema itself. The description adds no extra semantic detail beyond the schema, which is acceptable given full 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 and resource ('Delete a single email'), and the word 'single' implicitly distinguishes it from bulk deletion siblings like bulk_delete. However, it does not explicitly name or contrast with those 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 bulk_delete, move_email, or other deletion alternatives, and no preconditions or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the irreversible nature ('permanently'), which is real behavioral value, but it omits authentication/permission requirements, iCloud sync behavior, and whether any confirmation or recovery exists.

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 the verb leading and zero filler. It is efficient and well-structured, though the extreme brevity leaves the information content thin.

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 keyed delete with complete parameter documentation and no output schema, the essentials are present. However, a permanent destructive operation with no annotations arguably warrants more than one sentence covering irreversibility, permissions, and how to preview via dryRun.

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%, including a clear dryRun explanation, so the schema already documents every parameter. The description adds no format or syntax detail beyond that, which matches the baseline of 3 when 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?

States a specific verb+resource: deleting a single calendar event, and adds platform scope ('from iCloud Calendar') plus permanence. An agent can readily distinguish it from delete_calendar or delete_reminder, though it never explicitly contrasts with the sibling bulk_delete_events.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. It never tells the agent when to prefer this over bulk_delete_events for a single item or how it relates to get_event/list_events. Usage must be entirely inferred.

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 the critical empty-folder precondition, which is real added value, but says nothing about permanence/reversibility, what happens to subfolders, or whether the operation can be undone — gaps that matter for a destructive 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 short sentences, the action first and the precondition second; nothing is wasted and nothing needs to be read twice.

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 full schema coverage and a dryRun escape hatch, the description covers the essential constraint. Remaining gaps (permanence, subfolder handling) are modest given there is no output schema and the schema itself documents the safety valve.

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%, with both 'name' and 'dryRun' documented in the schema itself. The description adds no meaning beyond that (e.g., path format, anchoring, or dryRun behavior), so the baseline 3 applies.

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

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

States a specific verb and resource ('Delete a mailbox/folder'), which is unambiguous and distinct from sibling tools like delete_email, delete_calendar, and delete_reminder. It does not, however, explicitly contrast itself with adjacent siblings such as create_mailbox, rename_mailbox, or empty_trash.

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 folder must be empty first' is a genuine precondition that tells the agent when this call will fail, which is more than most terse definitions offer. But there is no guidance on alternatives (e.g., using delete_email or bulk_delete to clear contents, or empty_trash) and no statement of when to prefer this over those paths.

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, yet it says nothing about permanence, reversibility, or required permissions. It mentions 'Delete all' but never notes that this is a destructive, likely irreversible mass operation, and it does not surface the schema's dryRun safeguard, which matters a lot for a bulk 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?

A single efficient sentence that front-loads the verb and the subject. It earns its place but is arguably under-specified for a destructive bulk operation, which is a completeness issue rather than a conciseness one.

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 mass-destruction tool with no annotations and no output schema, the description is too thin. It omits the dryRun preview option, the mailbox scoping, and any warning about permanence—context an agent needs to invoke this safely.

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 days, dryRun, and mailbox are each already documented in the schema (including the dryRun safety semantics). The description adds no syntax or format detail beyond restating the day-threshold concept, 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?

States a specific verb ('Delete') with a precise resource and scope ('all emails older than a certain number of days' by a day threshold). This distinguishes it from generic deletes like delete_email or bulk_delete. However, it does not differentiate itself from the near-identical sibling archive_older_than, which shares the exact 'older than N days' pattern, leaving the agent to infer the destructive-vs-archive distinction.

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 guidance, no prerequisites, and no mention of alternatives such as archive_older_than or empty_trash. The description gives no indication of when this threshold-based bulk deletion is appropriate versus other delete tools in the sibling set.

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 critical trait that deletion is permanent (irreversible), which is valuable. However, it omits other behavioral context such as dry-run interaction, failure behavior, or permission requirements.

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

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

A single, front-loaded sentence that names the action and scope without any wasted words. It is appropriately sized for a simple delete 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 simple tool with full schema coverage and no output schema, the description is minimally sufficient to invoke correctly. However, it lacks sibling differentiation and usage context that would help an agent choose between deleting, completing, or updating a reminder.

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 all three parameters including dryRun. The description adds no additional parameter semantics, making the baseline 3 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 specific verb ('Delete') and resource ('a reminder from iCloud Reminders') plus an important scope qualifier ('permanently'). It does not explicitly differentiate from siblings such as complete_reminder or update_reminder, so it falls short of a 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?

No explicit when-to-use, when-not-to-use, or alternative guidance. The description only states what the tool does; it does not help an agent choose it over complete_reminder, update_reminder, or bulk delete 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 has to carry the whole behavioral burden. It usefully discloses a non-obvious precondition: the list must be empty. It does not say what happens when that precondition fails (error or refusal), whether the deletion is permanent, or whether confirmation is required.

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, and the destructive action is named before its preconditions. Every clause carries information the 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?

This is an unannotated mutation with no output schema, so the description should do more. The precondition and the name-uniqueness rule are covered, but failure behavior, irreversibility, and how dryRun changes the outcome are left to the schema and to inference.

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 both parameters are already documented and the baseline is 3. The description adds real meaning beyond the schema by saying the name must resolve to exactly one list, which tells the agent that an ambiguous name will not delete anything. It says nothing about dryRun, but the schema covers that field.

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?

"Delete a Reminders list" gives a specific verb plus resource, and the noun "list" cleanly separates it from the sibling delete_reminder and from delete_calendar or delete_mailbox. An agent can pick it out of the sibling set without opening the schema.

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 states the prerequisite (the list must be empty) and the name-matching condition (the name must match exactly one list), which controls when a call will succeed. It does not point at alternatives such as delete_reminder for removing individual reminders or rename_reminder_list, so it stops just 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 full behavioral burden and does not meet it: it never says the deletion is permanent, whether the rule must exist, or what happens on an unknown name. The one mitigating detail, the schema's dryRun flag, is never referenced in the description, so its role as a preview mechanism is left for the agent to discover in the schema.

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

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

A single front-loaded sentence with zero filler and the key constraint (identify by name) up front. It is efficient, though the terseness is a symptom of missing behavioral content rather than tight editing.

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?

This is an irreversible mutation with no annotations and no output schema, so the description is the only place to disclose safety and effect. It omits permanence, error behavior on a missing rule, and any mention of the dryRun preview, leaving an agent under-informed before a destructive call.

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 both 'name' and 'dryRun' are already documented at the field level; this sets the baseline at 3. The description's 'by name' phrase aligns with the required parameter but adds no syntax, matching rules, or case-sensitivity detail 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?

States a specific verb and resource ('Delete a saved rule') and scopes it to lookup by name, which cleanly separates it from create_rule, list_rules, and run_rule in the sibling set. It stops short of any explicit sibling differentiation, but the verb alone is a reliable discriminator.

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 versus run_rule, run_all_rules, or create_rule, and no prerequisites stated. The agent gets no hint about the existence of a dryRun safety path before invoking a destructive operation.

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 behavioral burden. It discloses a real behavioral rule (only non-all-day events, only same-date comparisons across different calendars), which is valuable. However, it omits that this is a read-only operation, what a returned conflict/gap record looks like, and any limits on calendar count or range size.

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 tight sentences, each earning its place: the first states purpose and scope, the second supplies the comparison rule. Purpose is front-loaded and there is no filler.

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 and no annotations, so the description must carry more. It explains the comparison logic but never describes what a detected conflict or tight gap returns, which is exactly what an agent needs to interpret results from a detection 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 100%, so the schema already documents since, before, minBuffer, and calendarIds with types and defaults. The description only echoes the 'tight gaps' concept behind minBuffer and the multi-calendar meaning of calendarIds, adding little beyond the structured fields. Baseline 3 applies when 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 names a specific verb (Detect) and resource (scheduling conflicts and tight gaps between events) and scopes it to multiple calendars, non-all-day events, and same-date comparisons. No sibling tool performs conflict detection, so this is unambiguously distinguished from list_events, search_events, and get_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?

Usage is only implied: the scope ('across multiple calendars', 'non-all-day events on the same date') suggests when the check is meaningful, but the description never states when to reach for this versus search_events or list_events_multi, nor any precondition such as needing calendar IDs up front. Adequate but with a clear gap.

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

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

No annotations provided, so description carries full disclosure burden. Successfully communicates destructive nature ('Permanently delete') and safety mechanism (dryRun preview). Missing return value description and rate limit details, but 'permanently' adequately warns of irreversibility.

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 waste. Front-loaded with critical behavioral info ('Permanently delete') immediately signaling danger, followed by safety instruction. Perfect density for the tool complexity.

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 single-parameter tool with 100% schema coverage and no output schema, the description is complete. Covers scope (trash folder), destructive nature, and safety mechanism. No significant gaps given the tool's simplicity.

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

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

Schema has 100% coverage (baseline 3). Description adds value beyond schema by prescribing usage semantics ('preview first') rather than just defining the boolean, helping the agent understand WHEN to set dryRun=true.

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?

Clear specific verb ('Permanently delete') + resource ('emails in the trash') + scope ('all'). Clarifies folder name variations ('Deleted Messages or Trash folder') to distinguish from other mailboxes, effectively differentiating from sibling deletion tools like bulk_delete or delete_email.

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

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

Provides explicit safety guidance ('Use dryRun: true to preview first') which establishes a recommended workflow before destructive execution. Lacks explicit comparison to siblings (e.g., when to use this vs bulk_delete), but the trash-specific scope makes usage context largely self-evident.

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 successfully indicates the bidirectional nature of the operation (both flagging and unflagging), but omits details about idempotency, error handling for invalid UIDs, or whether the operation is persistent/write-based.

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

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

The description is a single, efficient sentence with zero waste. It front-loads the core action and scope immediately, with no filler words or redundant explanations that duplicate the schema 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?

Given the tool's low complexity (3 simple parameters, 100% schema coverage) and lack of output schema, the description provides sufficient context for agent selection. It appropriately omits return value documentation (not required without output schema) but could be improved by noting the state-changing nature of the operation.

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

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

The input schema has 100% description coverage (uid, flagged, mailbox are all well-documented). Since the schema comprehensively defines parameter semantics including the default mailbox behavior, the description appropriately adds no redundant parameter details, meeting the baseline score 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 provides specific verbs ('Flag or unflag') and resource ('single email'), clearly distinguishing it from sibling tools like 'bulk_flag' by emphasizing the singular scope. It loses one point for not clarifying what 'flag' means in this email context (e.g., starring vs. marking as important).

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 constraints by specifying 'single email', suggesting it shouldn't be used for bulk operations. However, it fails to explicitly name 'bulk_flag' or 'bulk_flag_by_sender' as alternatives for multiple emails, leaving the agent to infer this from the naming convention alone.

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

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

With no annotations, the description carries the full burden. It discloses that the tool 'fetches the original email body' (read behavior) and formats it as a forwarded block, plus prepends notes. However, it omits whether the original email is marked as forwarded, if a copy appears in the sent folder, or what the return value indicates.

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 well-structured sentences: purpose statement, mechanism explanation, and feature support. No redundancy or filler. Each sentence adds distinct value (what it does, how it handles content, what formatting it supports).

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?

Adequate for basic invocation given the comprehensive schema, but gaps remain regarding side effects and return values due to the absence of annotations and output schema. Missing: whether the operation creates a sent item, marks the original, or returns the new message ID.

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%, establishing a baseline of 3. The description references 'one or more recipients' (to) and 'plain text and/or HTML note' (note/html), aligning with the schema but adding minimal semantic detail beyond what the schema already provides for the 6 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?

Clear verb ('Forward') and resource ('existing email'), with specific detail about including the original body as a forwarded block. Distinguishes implicitly from siblings like compose_email or reply_to_email by describing the forwarding mechanics, though it doesn't explicitly name 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?

No guidance on when to use this versus similar tools like reply_to_email or compose_email. Given the sibling list includes both reply_to_email and get_email, explicit differentiation (e.g., 'use this to send to new recipients rather than responding to the original sender') would prevent selection errors.

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 successfully discloses output format ('base64-encoded data'), size constraints ('Maximum 20 MB'), and pagination behavior. Lacks explicit read-only/safety declaration but 'download' implies non-destructive access.

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?

Four sentences with zero waste: purpose, return format, prerequisite workflow, and operational limits. Information is front-loaded and logically 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?

Comprehensive given no annotations or output schema. Covers return value format, prerequisites, and pagination strategy. Would be a 5 with explicit mention of error handling or idempotency, but adequately complete for safe 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 100% (baseline 3). Description adds valuable semantic context: linking partId to the list_attachments prerequisite and explaining that offset+length work together for paginated downloads of large files.

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 ('Download') and resource ('attachment'), clearly distinguishing this from sibling 'list_attachments' by implying content retrieval vs. metadata listing.

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 states the prerequisite workflow ('Use list_attachments first to get the partId') and provides clear pagination guidance for large files ('use offset+length for larger files'), covering both normal and edge-case 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?

No annotations provided, so description carries full burden. The verb 'Get' implies a read-only operation (safe, non-destructive), but lacks details on error behavior (e.g., invalid ID), rate limits, or specific return structure beyond 'full details'.

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

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

Two sentences with zero waste: first states purpose, second provides prerequisite workflow. Front-loaded with the core action and appropriately sized for the tool's simplicity.

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

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

For a single-parameter retrieval tool with complete schema coverage, the description is functionally complete. It omits specific return value structure (no output schema exists), but 'full details' provides sufficient context for an agent to infer this returns a contact object.

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

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

Schema has 100% description coverage with contactId defined as a UUID from sibling tools. Description reinforces this workflow ('by ID') but does not add syntax details, validation rules, or format constraints beyond what the schema already provides. Baseline 3 appropriate given complete 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 uses specific verb 'Get' with resource 'contact' and scope 'by ID'. It clearly distinguishes from sibling tools 'list_contacts' and 'search_contacts' by implying this is for direct ID lookup versus browsing/searching.

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 states when to use alternatives: 'Use list_contacts or search_contacts to find a contactId.' This provides clear workflow guidance (find ID first, then get details) and explicitly names sibling 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 provided, so description carries full burden. It successfully discloses behavioral semantics by explaining what the data represents (UIDs for skipping, skip counts for 'smart unsubscribe'), though it omits explicit read-only declaration or performance characteristics.

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?

Single efficient sentence with em-dash separated clauses. Front-loaded with action verb, followed by parenthetical elaboration. Zero waste; every clause explains a specific component of the returned state.

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

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

No output schema exists, but description fully compensates by enumerating the specific fields and their semantic purposes (e.g., 'to skip on next run'). Adequate for a parameter-less state retrieval 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?

Input schema has 0 parameters with 100% coverage. Per rubric, 0 params = baseline 4. Description appropriately does not mention parameters since none exist.

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?

Specific verb ('Get') + resource ('inbox digest state') with clear differentiation from siblings like get_inbox_summary via detailed field enumeration (last run timestamp, processed UIDs, pending actions, per-sender skip counts).

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 about what data is returned and implies workflow (processed UIDs 'to skip on next run'), but does not explicitly name alternatives (e.g., 'use update_digest_state to modify') or explicit when-not conditions.

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 but fails to state whether this marks the email as read, what happens if the UID doesn't exist, or the return format structure. 'Full content' hints at scope but safety profile and side effects are unspecified.

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?

Single sentence, nine words, front-loaded with action verb. No filler or redundant phrases. Given the high schema coverage, this efficient 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?

Minimum viable for a 4-parameter retrieval tool. While the schema covers parameters well, the absence of output schema and annotations leaves gaps regarding return structure and operational safety that the description does not fill. Adequate but could specify error handling or return format.

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

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

Schema description coverage is 100%, documenting all four parameters (uid, mailbox, maxChars, includeHeaders) adequately. The description mentions 'by UID' reinforcing the required parameter, but adds no semantic detail beyond the schema regarding character limits or header structure.

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 ('Get'), resource ('full content of a specific email'), and lookup method ('by UID'), distinguishing it from bulk retrieval siblings like get_emails_by_date_range. However, it does not explicitly differentiate from get_email_raw (likely returns MIME source) or clarify if this returns structured data vs. raw content.

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 provided on when to use this tool versus alternatives like get_email_raw, get_thread, or read_inbox. Does not mention prerequisites such as needing a valid UID from list_mailboxes or search_emails first.

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. Discloses critical behavioral traits: base64 encoding format, inclusion of 'full headers + MIME body', and 'Capped at 1 MB' size limitation. Could improve by stating error behavior when limit exceeded.

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: core action (sentence 1), use case guidance (sentence 2), limitation warning (sentence 3). Front-loaded with the most critical information (RFC 2822 source).

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-parameter fetch operation without output schema, description adequately covers return format, size constraints, and intended use cases. Missing only explicit read-only safety declaration, though implied by 'Get'.

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% ('Email UID', 'Mailbox name'), so baseline is 3. Description does not add parameter semantics beyond what schema provides, but none are needed given complete 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?

Specific verb 'Get' + precise resource 'raw RFC 2822 source' + format 'base64-encoded' clearly distinguishes from sibling 'get_email' by emphasizing raw headers/MIME body vs parsed content.

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?

States 'Useful for debugging or export' providing clear contextual guidance on when to use this over standard email retrieval. Lacks explicit 'when not to use' or named alternative, but the niche use case is clearly signaled.

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 burden for behavioral disclosure, yet it fails to indicate whether this is a read-only operation, what data structure is returned, or how pagination/limiting behaves despite the presence of a limit parameter.

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?

Single sentence is efficiently worded without redundancy and places the core action at the front; however, it is arguably too brief given the tool's complexity and lack of supporting annotations.

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 4 parameters, no output schema, no annotations, and numerous sibling retrieval tools, the 5-word description is insufficiently complete to support confident tool selection and 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?

Input schema has 100% description coverage for all 4 parameters (startDate, endDate, mailbox, limit), so the schema carries the semantic weight; the description adds no additional parameter context beyond implying date-range filtering.

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

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

Description clearly states the action ('Get') and resource ('emails') with specific scope ('between two dates'), but fails to differentiate from siblings like search_emails or get_emails_by_sender that could overlap in functionality.

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 no guidance on when to use this tool versus alternatives such as search_emails (which supports complex filtering) or get_emails_by_sender, nor any prerequisites or constraints beyond the date 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?

No annotations are provided, so the description must carry full behavioral disclosure burden. It fails to clarify whether results include full message bodies or just metadata (given 'get_email' exists for individual retrieval), pagination behavior, or the conflict between 'all' and the limit parameter.

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

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

The single-sentence structure is appropriately brief, but the use of 'all' is misleading given the limit parameter, wasting the limited descriptive real estate on inaccurate scope definition.

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 50+ sibling tools including multiple search/retrieval variants and no output schema, the description is insufficient. It should clarify return format (list of IDs vs full objects), distinguish from 'search_emails', and explain the domain-search capability implied by the parameter 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?

With 100% schema description coverage (all 3 parameters documented), the baseline is 3. The description adds no additional parameter context (e.g., that 'sender' accepts domains per the schema description, or that 'limit' defaults to 10).

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 core action (Get) and filter (specific sender), but claims 'all' emails which contradicts the default limit of 10 in the schema. It also fails to distinguish from the sibling 'search_emails' tool, which likely overlaps in functionality.

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 provided on when to use this versus 'search_emails' or 'get_emails_by_date_range'. Does not mention prerequisites like mailbox access permissions or whether sender accepts domains (as hinted in parameter 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?

No annotations are provided, so the description must carry the burden. 'Get' implies a read-only operation and 'full details' suggests comprehensive data return, but it lacks disclosure of error handling (e.g., event not found) or authorization requirements.

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

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

Single sentence of appropriate length with no redundant words. Information is front-loaded with the action ('Get full details') immediately clear.

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 retrieval tool with complete schema coverage, the description adequately covers the tool's purpose and scope. Minor gap regarding error behavior keeps it from a 5.

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