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?

With no annotations provided, the description carries the full burden and successfully discloses implementation details (chunks of 250, per-chunk timeouts) and safety mechanisms (dryRun). It could be improved by explicitly stating the destructive/irreversible nature or timeout failure behavior.

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

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

Three sentences with zero waste: front-loaded with the core action, followed by implementation details, and ending with safety guidance. Every sentence earns its place with specific, 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?

Given 13 parameters and destructive capabilities with zero required parameters (risk of deleting everything if called with empty args), the description is missing critical safety warnings. It covers chunking and dryRun but fails to warn about the empty-filter scenario or explain expected outcomes without an output schema.

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

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

While the schema has 100% coverage (baseline 3), the description adds valuable semantic context about how parameters interact ('any combination of filters') and provides usage syntax for the dryRun parameter, enhancing understanding beyond the schema definitions.

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 (Delete), resource (emails), and method (matching any combination of filters). It effectively distinguishes from sibling tools like 'bulk_delete_by_sender' or single 'delete_email' by emphasizing the flexible, combinatorial filter approach.

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

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

The description provides explicit guidance on using dryRun for safe preview, which is valuable behavioral instruction. However, it lacks guidance on when to use this versus more specific alternatives (like 'bulk_delete_by_sender') or warnings about the zero required 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 carries the full burden of behavioral disclosure. While 'Delete' implies a destructive operation, the description fails to specify whether emails are moved to trash or permanently deleted, whether the operation is reversible, or if there are rate limits for 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?

The description is a single efficient sentence with no waste. However, it may be overly terse given the lack of annotations and the destructive nature of the operation; additional context about behavioral traits would improve utility without harming clarity.

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

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

For a destructive bulk operation with no output schema and numerous sibling alternatives, the description is incomplete. It lacks safety warnings, recovery information (trash vs permanent), and guidance on the mailbox parameter's role in scoping 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?

With 100% schema description coverage, the schema already documents both 'sender' and 'mailbox' parameters. The description mentions 'specific sender' which aligns with the required parameter, but adds no additional semantic context (e.g., format expectations, case sensitivity) beyond what the schema provides. Baseline 3 is appropriate for high schema coverage.

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

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

The description clearly states the verb (Delete), resource (emails), and filter scope (all from a specific sender). The phrase 'all emails' distinguishes this from the single 'delete_email' sibling, and 'from a specific sender' distinguishes it from 'bulk_delete_by_subject' and general 'bulk_delete'.

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_delete' (which may use different filters) or 'delete_email' (single item). Given the large number of bulk operation siblings, explicit selection criteria would help prevent incorrect tool selection.

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

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

No annotations are provided, so the description carries full burden. While 'Delete' implies destruction, it lacks critical details: whether deletion is permanent or moves to trash, if the pattern matching supports wildcards/regex, case sensitivity, 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?

Extremely concise at 7 words with the action verb front-loaded. No filler words, though brevity comes at the cost of safety warnings and behavioral details that would be appropriate for a destructive bulk 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?

Given this is a destructive bulk operation with no annotations and no output schema, the description is dangerously minimal. It omits irreversibility warnings, confirmation requirements, and scope limitations (subfolders, date ranges) that would help an agent use 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 coverage is 100%, establishing a baseline of 3. The description adds 'pattern' which hints at matching behavior (substring vs exact), but doesn't clarify pattern syntax, case sensitivity, or mailbox scoping beyond what the schema already documents.

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 clear verb (Delete), resource (emails), and scope (matching a subject pattern). It implicitly distinguishes from siblings like bulk_delete_by_sender by specifying 'subject pattern', though it doesn't explicitly compare against 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 tool versus bulk_delete, bulk_delete_by_sender, or delete_older_than. No warnings about the destructive nature or prerequisites like confirming the mailbox selection.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. While 'Flag or unflag' indicates mutation, the description fails to mention operational limits (like the 500-email limit for attachment scanning noted only in the schema), error handling, or performance characteristics 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?

The description is a single, efficient sentence front-loaded with the action verbs. However, extreme brevity (9 words) contributes to underspecification for a complex 12-parameter tool; additional context on scope or safety would justify a longer description.

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 bulk mutation tool with 12 filtering parameters, no annotations, and no output schema, the 9-word description is inadequate. It lacks safety warnings about mass-modifying email states, return value documentation, or guidance on the 'hasAttachment' limitation.

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 across 12 parameters, the schema carries the semantic load. The description adds minimal parameter context beyond acknowledging 'filters' generally. It does not clarify the relationship between the required 'flagged' parameter and the 'Flag or unflag' action described.

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 verbs ('Flag or unflag') and identifies the resource ('emails'). It distinguishes from singular 'flag_email' by specifying 'in bulk' and implies differentiation from 'bulk_flag_by_sender' by emphasizing 'any combination of filters'. However, it could explicitly clarify when to use this versus the sender-specific variant.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'flag_email' (single) or 'bulk_flag_by_sender'. It omits prerequisites, safety warnings for bulk operations, or whether this operation is reversible.

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. While it specifies the scope ('all emails'), it fails to mention whether the operation is idempotent, what happens to emails already in the target state, potential performance implications of bulk operations, or any permission requirements.

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

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

The description is a single, efficient sentence that front-loads the action. There is no redundant or wasted text; every word serves to define the tool's core function.

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 tool without an output schema, the description covers the essential function but remains minimal. Given this is a bulk operation affecting potentially many emails, the lack of guidance on error handling, empty results, or confirmation mechanisms leaves it at minimum viability rather than 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?

With 100% schema description coverage, the baseline is 3. The description adds minimal semantic value beyond the schema, though it maps the 'flagged' boolean conceptually to the 'Flag or unflag' action. It does not elaborate on parameter formats, validation rules, or the default mailbox behavior beyond what the schema states.

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 clear action ('Flag or unflag'), resource ('emails'), and scope ('all emails from a specific sender'). It implicitly distinguishes from sibling tools like 'flag_email' (single) and 'bulk_flag' (general criteria) by specifying 'by sender' in the name and 'specific sender' in the description, though it doesn't explicitly contrast with 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?

The description offers no guidance on when to use this tool versus alternatives like 'bulk_flag' (which may filter by different criteria) or 'flag_email' (for single messages). There are no stated prerequisites, exclusions, or conditions that would help an agent select this over similar 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?

With no annotations provided, the description carries full burden but omits critical safety context: it doesn't warn that this mutates email state, affects potentially thousands of emails if unfiltered, or mention that 'bulk_mark_unread' can reverse it. For a bulk write operation, this lack of behavioral disclosure is a significant gap.

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

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

Single sentence, front-loaded with the primary action ('Mark all emails as read'), followed by the conditional scope. No redundancy or filler. Efficient length for the complexity level.

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 a two-parameter tool with complete schema documentation, but falls short for a bulk mutation operation. Missing: return value description, safety warnings about unfiltered usage, and reversibility notes. However, given the simple parameter structure and lack of output schema, it meets minimum viability.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds conceptual framing ('optionally filtered by sender') that aligns with the schema parameters, but doesn't provide syntax examples, format constraints, or semantic relationships beyond what's already in the schema.

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

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

The description clearly states the action ('Mark... as read') and resource ('emails'), using 'all' to indicate bulk scope. The phrase 'optionally filtered by sender' distinguishes it from date-based bulk variants like 'mark_older_than_read' and implies the difference from single-email 'mark_as_read', though it doesn't explicitly name siblings.

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

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

No explicit guidance on when to use this versus 'mark_as_read' (single email) or 'mark_older_than_read' (date-based). No warning about the scope of 'all emails' or prerequisites. The agent must infer usage solely from the parameter descriptions.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure, yet it omits critical context: this is a destructive mutation affecting potentially thousands of emails, whether the operation is reversible, performance implications of 'all', or threading behavior. The agent gets no warning about the scope of impact.

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, efficiently structured sentence of 9 words. It front-loads the primary action and appends the conditional filter without waste or redundancy.

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

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

For a bulk mutation tool with no output schema and no annotations, the description is minimally adequate. It covers the basic operation but lacks important contextual safeguards regarding the 'all' scope, potential volume of affected emails, or confirmation requirements that would help an agent invoke this 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?

The input schema has 100% description coverage ('Mailbox' and 'Optional: only mark emails from this sender'), so the baseline is 3. The description adds minimal semantic value beyond the schema, merely noting the filtering capability without elaborating on mailbox format constraints or sender string syntax.

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 core action ('Mark all emails as unread') and scope ('all'), with the specific state change (unread) distinguishing it from sibling tools like bulk_mark_read. However, it does not explicitly differentiate this bulk operation from singular alternatives like 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 mentions the optional sender filter but provides no guidance on when to use this tool versus alternatives like mark_as_read (single email) or bulk_mark_read. There are no stated prerequisites, exclusions, or conditions for proper usage.

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

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

With no annotations 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?

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?

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?

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?

With no annotations provided, the description carries the full burden. It discloses the critical safety trait that deletion is 'permanent' (irreversible), but lacks other behavioral details such as error handling when contactId doesn't exist, authentication requirements, or side effects.

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

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

Seven words, one sentence. Every element earns its place: action verb, resource, system boundary, and safety warning ('permanently'). No filler or redundancy. Perfectly front-loaded and sized for the operation 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?

Given the low complexity (single required string parameter) and 100% schema coverage, the description adequately covers the operation's intent and critical safety warning. Lacks explicit mention of error states or success indicators, but sufficient for a simple destructive CRUD operation without output schema.

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

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

Schema description coverage is 100%, with 'contactId' fully described as 'Contact ID to delete'. The description implies a single identifier is needed but adds no syntax details, format examples, or semantics beyond what the schema already provides, 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 ('Delete'), resource ('contact'), system context ('iCloud Contacts'), and scope modifier ('permanently'). It clearly distinguishes from siblings like create_contact, update_contact, and get_contact by specifying the destructive removal operation.

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 word 'permanently' implies this is for irreversible removal, but there is no explicit guidance on when to use this versus update_contact, or prerequisites like verifying the contact exists first. Usage is implied by the verb but not explicitly contextualized.

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. Critical omission: fails to disclose whether deletion is permanent or moves to trash (empty_trash sibling implies trash exists), whether the operation is reversible, or error behavior when UID doesn't exist.

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

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

Extremely terse (3 words) which prevents waste, but for a destructive operation this is insufficiently front-loaded with safety warnings or behavioral context. The brevity costs necessary information density.

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 destructive operation with no output schema. Missing critical safety context: no explanation of trash vs. permanent deletion, no return value description, and no error handling guidance despite the irreversible nature of the action.

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 (uid, mailbox), so baseline is adequate. Description implies single-item operation matching the uid parameter, but adds no syntax details, format examples, or behavioral context 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?

States specific verb (Delete) and resource (email), and distinguishes from bulk_delete/bulk_delete_by_sender siblings by specifying 'single'. However, it does not differentiate from delete_older_than or clarify the deletion mechanism (permanent vs. trash) despite empty_trash being a 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?

Provides no guidance on when to use this versus bulk_delete for multiple emails, or versus delete_older_than for cleanup. No mention of prerequisites like email existence or mailbox selection strategy.

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. It discloses the critical behavioral trait that deletion is 'permanent', which distinguishes it from trash/archive patterns. However, it lacks details about authorization requirements, side effects on event attendees, or reversibility windows.

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 with zero waste. 'Permanently' efficiently conveys destructiveness without extra words, and 'iCloud Calendar' front-loads the domain context immediately. Every word earns its place.

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

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

For a straightforward 2-parameter deletion tool without output schema, the description adequately covers the essential safety context (permanence) and system boundary (iCloud). Could be improved by noting where to obtain the IDs (e.g., from list_events), but sufficient for correct invocation.

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

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

Schema description coverage is 100% with clear descriptions for calendarId and eventId. The description does not add parameter-specific guidance (such as ID formats or source locations), but with complete schema coverage, no additional compensation is required.

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

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

The description uses specific verb 'Delete' with resource 'calendar event' and specifies 'permanently from iCloud Calendar'. This clearly distinguishes it from sibling delete_email and distinguishes from update_event/create_event by explicitly stating the destructive action and target system.

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 word 'permanently' implies this is for irreversible removal, suggesting when to use it versus update_event, but lacks explicit when-to-use guidance or named alternatives (e.g., does not mention using update_event for modifications instead of deletion).

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

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

No annotations provided, so description carries full burden. Mentions the empty-folder constraint but omits other critical behavioral details: whether deletion is permanent, what error occurs if preconditions fail, 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?

Two sentences, zero waste. Front-loaded with action, followed by constraint. Efficient and appropriately sized for the tool's 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?

Minimum viable for a single-parameter tool. Covers the essential constraint but lacks safety warnings appropriate for a destructive operation, especially given absent annotations and no output schema to indicate success/failure modes.

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 ('Mailbox path to delete'), so the structured data fully documents the parameter. Description adds no parameter-specific details, meeting baseline expectations for high-coverage schemas.

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 action (Delete) and resource (mailbox/folder) clearly. Distinguishes from sibling 'delete_email' by specifying folder-level operation, though could explicitly contrast with 'empty_trash' or 'bulk_delete'.

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 critical prerequisite ('folder must be empty first'), which implies when the tool will fail. However, lacks explicit guidance on when to use versus alternatives like 'empty_trash' or how to handle non-empty folders.

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 provides minimal safety context. It does not specify whether deleted emails move to trash (recoverable) or are permanently deleted, nor does it mention performance implications of bulk operations or verification requirements.

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

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

The description is a single, efficient sentence of nine words with no redundancy. However, extreme brevity comes at the cost of omitting critical safety and behavioral context that a destructive bulk operation demands.

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 operation with no annotations and no output schema, the description is inadequate. It fails to explain return values (success confirmation, count deleted), reversibility (trash vs permanent), or preconditions (permissions, mailbox existence validation).

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 both 'days' and 'mailbox' parameters fully documented in the schema. The description references the date threshold ('older than a certain number of days') which aligns with the schema, meeting the baseline expectation when structured documentation is complete.

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

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

The description clearly states the action (Delete), resource (emails), and scope (older than X days). However, it fails to distinguish from the sibling tool 'archive_older_than', which has similar parameters but fundamentally different outcomes (preservation vs removal).

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

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

No guidance is provided on when to use this tool versus 'archive_older_than' (for non-destructive cleanup) or versus 'bulk_delete' (which may use different selection criteria). Given the irreversible nature of deletion, this lack of comparative guidance is a significant gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Delete' implies destruction, the description fails to mention whether this operation is permanent, what happens if the rule doesn't exist, or whether it affects emails already processed by the rule.

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

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

The description is extremely concise at six words with no filler. It front-loads the action ('Delete') and immediately specifies the scope ('a saved rule by name'), making it easy to scan.

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

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

Given the low complexity (single string parameter, no output schema, no nested objects), the description is minimally sufficient. However, for a destructive operation with no annotations, it should include safety warnings or error condition notes 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?

Schema coverage is 100% with the 'name' parameter fully documented as 'Rule name to delete'. The description mentions 'by name' which aligns with the schema, but adds no additional semantic context (e.g., case sensitivity, whether it's the display name or internal ID) 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 provides a clear verb ('Delete') and resource ('saved rule') and distinguishes from siblings like 'run_rule' or 'create_rule' through the action word. However, it doesn't explicitly clarify what constitutes a 'rule' in this email context or mention how it differs from bulk deletion tools.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives like 'run_rule' or 'create_rule', nor does it mention prerequisites such as the rule needing to exist first. It states only what the tool does, not when to choose it.

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

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

No annotations 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.

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

With 100% schema description coverage, the structured fields adequately document parameters. The description does not add parameter semantics, but the baseline 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 specific verb 'Get' with resource 'calendar event' and scope 'by its ID', clearly distinguishing it from sibling tools like list_events, search_events, create_event, and delete_event.

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

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

The phrase 'by its ID' implies usage when a specific identifier is known, likely from list_events or search_events (referenced in schema), but lacks explicit when-to-use guidance or named 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, the description does not explicitly confirm this is read-only, safe, or without side effects. It also fails to define what constitutes 'recent' (time window) or mention any rate limits or authentication requirements.

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

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

The description is a single, efficient sentence that places the action verb at the beginning. It avoids redundancy with the schema, though its brevity contributes to the lack of differentiation from sibling tools.

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 (2 parameters, no nested objects, no output schema), the description minimally suffices by indicating the return value structure. However, it lacks completeness regarding the tool's relationship to 'get_mailbox_summary' and does not clarify behavioral safety in the absence of annotations.

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 for both parameters ('mailbox' and 'account'), including default values. The description does not add semantic meaning beyond what the schema already provides, which warrants the baseline score of 3 for high schema coverage.

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

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

The description states the action ('Get a summary') and return value ('total, unread, and recent email counts'), but creates ambiguity with the sibling tool 'get_mailbox_summary'. It fails to clarify whether this tool is inbox-specific (as the name suggests) or works for any mailbox (as the description and parameter suggest), leaving the agent uncertain about which tool to select.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_mailbox_summary', 'count_emails', or 'read_inbox'. The description does not mention prerequisites or conditions for use, despite the existence of functionally similar sibling 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 provided, so description carries full burden. States it retrieves counts but fails to define what 'recent' means (time window?), disclose performance characteristics, or describe the return structure.

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 front-loaded with specific metrics (total, unread, recent). Zero redundancy; every word specifies scope or resource.

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 a simple single-parameter read operation. Minor gap: undefined 'recent' metric and no output schema, though the three count types are enumerated.

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 the 'mailbox' parameter well-documented ('Mailbox path to summarize'). Description mentions 'mailbox/folder' but adds no semantic details beyond the schema (e.g., case sensitivity, path separators, validation rules).

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' with clear resource 'mailbox/folder' and precise scope 'total, unread, and recent email counts'. Effectively distinguishes from sibling 'get_inbox_summary' by emphasizing 'any specific' folder capability.

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?

Implies usage for arbitrary folders via 'any specific mailbox/folder', differentiating it from inbox-specific tools, but lacks explicit when-to-use guidance or named alternatives like 'count_emails' or 'get_inbox_summary'.

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 behavioral disclosure burden. It effectively communicates key traits: it returns 'progress, chunk statuses, and any failures', operates on 'current or most recent' operation (statefulness), and handles 'long-running' async 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?

Three well-structured sentences: first states core purpose, second describes return data, third provides usage guidance. Every sentence earns its place with zero redundancy or 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?

Despite no output schema, the description adequately explains what information is returned (progress, chunks, failures). Given zero parameters and the specific monitoring purpose, the description provides sufficient context for correct invocation.

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

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

Input schema has 0 parameters, which per guidelines sets baseline 4. The description correctly implies no inputs are required by focusing entirely on the operation's behavior and output.

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 'Check' with resource 'status of the current or most recent bulk move operation', clearly distinguishing it from sibling tools like 'bulk_move' (which initiates moves) and 'abandon_move' (which cancels 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 when-to-use guidance ('Call this to monitor a long-running move or inspect a failed one'), clearly indicating this is for polling/inspection rather than initiation. Does not explicitly name alternative tools, though the context makes the distinction clear.

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

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

With no annotations provided, description carries the full burden and successfully discloses implementation methodology: it uses 'SEARCH LARGER queries' for bucketing and performs 'sampling' (not exhaustive analysis). Does not mention performance costs or read-only nature, though implied by 'Estimate' and 'get' prefix.

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 value proposition (what it does), second sentence explains methodology (how it works). Every word earns its place.

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

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

For a 2-parameter analysis tool with no output schema, the description adequately explains what the report contains (size buckets, top senders by size). Could be improved by noting that results are estimates/samples, but sufficient for tool selection.

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 connecting sampleSize to 'sender analysis' and implying mailbox scopes the storage analysis, providing functional context beyond the schema's mechanical 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 specific actions: 'Estimate storage usage by size bucket' and 'identify top senders by email size.' Effectively distinguishes from sibling get_top_senders by specifying size-based analysis rather than frequency-based analysis.

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 implicit context that this is for storage analysis, but lacks explicit when-to-use guidance versus alternatives like get_mailbox_summary or search_emails. Does not specify prerequisites or when to prefer this over get_top_senders.

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 zero annotations provided, description carries full disclosure burden excellently. Reveals implementation algorithm (subject matching + References/In-Reply-To headers) and platform-specific limitation (iCloud lacks server-side threading, results approximate). No contradictions with annotations.

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

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

Three sentences with zero waste: sentence 1 states purpose, sentence 2 reveals implementation method, sentence 3 warns about platform limitation. Front-loaded with action and resource. Efficient density of 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 no annotations and no output schema, description adequately covers behavioral complexity (threading logic, header parsing, platform variance). Missing only minor details like return format or error handling for invalid UIDs, but explains the critical approximation caveat for iCloud users.

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 (uid defined as 'Email UID to find the thread for', mailbox as 'Mailbox to search'). Description implies uid references the anchor email but doesn't add syntax, format constraints, or validation rules beyond schema. Baseline 3 appropriate 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?

Description opens with specific verb 'Find' + resource 'emails' + scope 'in the same thread as a given email', clearly distinguishing from sibling get_email (single email retrieval) and search_emails (general criteria search). The threading concept is unambiguous.

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

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

Provides important technical context about iCloud limitations and result approximation, implying reliability concerns. However, lacks explicit guidance on when to use this versus search_emails or get_email for conversation reconstruction, and doesn't specify prerequisites like UID validity.

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 sampling behavior (non-exhaustive analysis), but omits safety characteristics (read-only status), performance implications of large sample sizes, or return value structure.

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 that is front-loaded with the action ('Get the top senders') and efficiently qualifies it with the metric ('by email count') and scope ('from a sample'). No redundant words or wasted space.

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

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

For a 3-parameter analytical tool with simple types and no output schema, the description adequately covers the core functionality and key limitation (sampling). It appropriately relies on the schema for parameter details, though explicit read-only assurance would improve completeness given the lack of annotations.

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 provides context that 'sampleSize' relates to inbox sampling, but does not add syntax details, valid ranges, or semantic relationships beyond what the schema property descriptions already provide.

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

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

The description clearly states the tool retrieves sender frequency data ('top senders by email count') and specifies the methodology ('from a sample'). However, it does not explicitly distinguish from sibling tool 'get_unread_senders', which likely performs similar ranking but only on unread messages.

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 mention of 'sample' implicitly signals this is for approximate/quick analysis rather than exhaustive reporting, which helps usage context. However, there is no explicit guidance on when to choose this over 'get_emails_by_sender' or 'search_emails' for sender analysis.

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 is read-only (implied by 'Get' but not explicit), what data structure is returned, or how 'top' is calculated. No mention of pagination or rate limits.

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 (6 words) and front-loaded with no filler. While not wasteful, the brevity contributes to under-specification given the lack of annotations and output schema.

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

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

Given the absence of an output schema and annotations, the description should explain the return format (list of sender strings? objects with counts?) and ranking logic. It provides neither, leaving significant gaps for an agent attempting to interpret results or handle errors.

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

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

Schema coverage is 100%, so the schema adequately documents all three parameters (mailbox, sampleSize, maxResults). The description mentions 'top senders' which loosely maps to maxResults, but doesn't add syntax details or usage guidance beyond the schema definitions. Baseline score appropriate given schema 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 states a clear verb ('Get') and resource ('senders of unread emails'), and the 'unread' qualifier distinguishes it from sibling tool 'get_top_senders'. However, it doesn't define what 'top' means (frequency, recency, etc.), leaving the ranking criteria ambiguous.

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

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

No guidance provided on when to use this versus 'get_top_senders', 'get_inbox_summary', or 'search_emails'. No mention of prerequisites, performance implications of the sampleSize parameter, or when bulk operations might be preferred.

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

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

No annotations provided, so description carries full burden. It discloses the parsing behavior (splitting into email/URL components) which explains output structure, but fails to declare safety properties (read-only), error behavior when header is missing, or whether the operation is idempotent.

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 totaling 17 words. First sentence front-loads the core function; second provides use-case context. No redundancy or filler. Every word earns its place.

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

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

For a 2-parameter tool with no output schema, the description partially compensates by describing the return structure ('parsed into email and URL components'). However, it omits behavior when the header is absent. Reasonably complete for low-complexity tool but could specify return format more explicitly.

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 'uid' and 'mailbox' already well-described in the input schema. Description adds no additional parameter semantics (e.g., UID format, mailbox path conventions), so baseline 3 is appropriate per scoring rules for high-coverage schemas.

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 provides specific verb ('Get'), exact resource ('List-Unsubscribe header'), and processing detail ('parsed into email and URL components'). Clearly distinguishes from sibling 'get_email' by specifying header-specific extraction rather than full message retrieval.

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 implied usage context ('Useful for AI-assisted inbox cleanup') suggesting when to use it, but lacks explicit when-not guidance or comparison to alternatives like using 'get_email' and parsing manually. No mention of prerequisites like email UID availability.

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. Mentions return content (names and hosts) but omits safety profile (read-only), error handling, return format structure, or idempotency 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?

Two sentences with zero waste: first states purpose, second states usage context. Front-loaded with action verb and immediately useful. 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?

Adequate for a simple parameter-less tool. Mentions what data is returned despite lack of output schema. Could improve by specifying return format (array vs object) or empty-state behavior, but sufficient for 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?

Zero parameters present (empty schema). Per rubric, baseline is 4 for zero-parameter tools. Description appropriately focuses on return value usage rather than nonexistent inputs.

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 uses specific verb 'List' with clear resource 'configured email accounts' and specifies returned fields (names and IMAP hosts). Distinct from sibling list_mailboxes by focusing on account configuration rather than folders.

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 to 'Use the account name in any mail tool's account parameter,' establishing clear workflow relationship to sibling tools. Lacks explicit 'when not to use' exclusions, but context is clear.

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

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

With no annotations provided, the description carries the full burden and effectively discloses the return structure (filename, MIME type, size, IMAP part ID) and the non-destructive, read-only nature of the operation. It could improve by mentioning behavior when no attachments exist.

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

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

Two efficiently structured sentences with zero waste: first establishes the action and key behavioral constraint (no download), second specifies return fields. Information is front-loaded and dense.

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

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

Given the absence of an output schema, the description appropriately enumerates the returned fields for each attachment. For a 2-parameter tool with complete schema coverage, this is sufficient, though explicitly stating it returns an array would be ideal.

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 ('Email UID', 'Mailbox name'), meeting the baseline. The description adds context by stating these parameters identify 'an email' but does not elaborate on UID format or mailbox naming conventions beyond the schema.

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

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

The description clearly states the specific action (List) and resource (attachments), and distinguishes from sibling tool 'get_attachment' by emphasizing 'without downloading them', clarifying this is a metadata-only operation.

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 'without downloading them' implicitly guides the agent to use this for metadata inspection versus 'get_attachment' for content retrieval. However, it lacks explicit 'when not to use' guidance or prerequisites (e.g., requiring the email UID to exist).

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. It discloses return fields (calendarId, name, supported event types) which compensates for the missing output schema. However, it omits safety characteristics (read-only), idempotency, or rate limiting that would help an agent understand operational constraints.

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 efficiently structured sentences with zero waste. First sentence establishes scope with examples; second sentence discloses return values. Information is front-loaded and appropriately sized for the tool's simplicity.

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

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

Given the tool's low complexity (no parameters, simple list operation) and absence of output schema, the description adequately covers return values. It could be improved by noting that no authentication parameters are required (since iCloud auth is implicit), but this is sufficient for agent selection.

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. According to scoring rules, 0 parameters establishes a baseline score of 4. The description does not need to compensate for parameter documentation gaps.

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

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

The description uses specific verb 'List' with resource 'calendars' and context 'iCloud Calendar'. Examples (Personal, Work, LSAT PREP) clarify scope. It clearly distinguishes from sibling 'list_events' by targeting calendar containers rather than individual 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 implies usage through the return value disclosure (calendarId), suggesting it's for discovering available calendars. However, it lacks explicit guidance on when to use this versus 'list_events' or prerequisites like 'use this first to get calendarIds before creating events'.

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?

Without annotations, the description carries the burden of disclosure and successfully specifies return fields (names, phones, emails) compensating for the missing output schema. However, it omits explicit safety declarations (read-only nature) or pagination behavior 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 establishes scope and source (iCloud Contacts), second discloses return payload structure. Every element 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 2-parameter tool with no output schema, the description adequately covers the data returned and source system. Could be improved by noting this retrieves all contacts (subject to pagination) versus filtered results, but sufficient for correct invocation.

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

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

With 100% schema description coverage for both parameters (limit and offset), the schema fully documents the pagination interface. The description adds no supplemental parameter semantics, meeting the baseline for high-coverage schemas.

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 'List' with resource 'contacts from iCloud Contacts', clearly distinguishing it from sibling tools like get_contact (singular retrieval), search_contacts (filtered query), and mutation tools like create_contact/delete_contact.

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

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

Usage is implied by the verb 'List' suggesting bulk enumeration versus siblings like 'search' or 'get', but provides no explicit guidance on when to prefer this over search_contacts or whether it returns all contacts versus a default subset.

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. States read operation ('List') and date range scoping, but omits output format details, pagination behavior, or what occurs when no events match. Adequate but minimal behavioral 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?

Two sentences with zero waste: first states purpose, second states prerequisite. Perfectly front-loaded and appropriately sized for the tool's 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 4-parameter listing tool with complete schema documentation, description is sufficiently complete. The prerequisite instruction is critical for successful invocation. Minor gap: does not describe return value structure (array of event objects?), though absence of output schema makes this less strictly required.

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

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

Input schema has 100% description coverage, establishing baseline of 3. Description adds valuable workflow context for calendarId parameter ('from list_calendars'), but does not augment understanding of date range parameters (since/before) or limit beyond schema descriptions.

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

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

Description uses specific verb 'List' with clear resource 'events in a specific iCloud calendar' and scope 'within a date range'. Effectively distinguishes from sibling operations like create_event, delete_event, and get_event (single retrieval).

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 prerequisite 'Use list_calendars first to get a calendarId', establishing clear workflow. Lacks explicit differentiation from search_events (text search alternative) or guidance on when to use date range vs. other filtering methods.

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

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

No annotations are provided, so the description must carry the full burden. It clearly indicates this is a read operation by using 'List', but lacks disclosure of what specific data is returned (e.g., folder names, IDs, hierarchy levels, message counts) since no output schema exists to supplement this information.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the action verb and immediately communicates scope, making it perfectly sized for a parameterless utility function.

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

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

Given the tool's simplicity (no input parameters) and lack of output schema, the description adequately covers the core functionality. It could be improved by briefly describing the return structure (e.g., 'returns folder names and paths'), but remains complete enough for agent selection.

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. Per the evaluation rules, 0 parameters establishes a baseline score of 4, as there are no parameter semantics to clarify beyond the schema itself.

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

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

The description provides a specific verb ('List'), clear resource ('mailboxes/folders'), and scope ('all...in iCloud Mail'). It effectively distinguishes from siblings like create_mailbox, delete_mailbox, and get_mailbox_summary by emphasizing the enumeration aspect.

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?

While 'List all' implies this is for retrieving folder structure enumeration, there is no explicit guidance on when to use this versus get_mailbox_summary (which likely returns statistics) or other mailbox-related operations. Usage is implied but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It partially compensates by describing the return content (filters, actions, run history), but omits explicit safety declarations (read-only status), pagination behavior, or permission requirements that would be essential for a complete behavioral picture.

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 no wasted words. Every phrase earns its place: 'List all saved rules' establishes the operation, while 'with their filters, actions, and run history' provides necessary specificity about the data richness without redundancy.

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

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

Given the tool has no parameters, no annotations, and no output schema, the description adequately compensates by hinting at the return structure through the field enumeration (filters, actions, run history). However, it could be improved by noting the read-only nature or pagination limits given the lack of annotations.

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, which establishes a baseline score of 4 per the scoring rules. The description appropriately does not mention parameters since none exist, and the schema coverage is 100% (trivially, as there are no parameters to document).

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 ('List') and resource ('saved rules'), and distinguishes from siblings by specifying the detailed scope includes 'filters, actions, and run history' rather than just rule names or IDs. This clearly differentiates it from create_rule, delete_rule, and run_rule.

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?

While the description implies this is for inspection/auditing of existing rules (vs. creating or running them), it provides no explicit when-to-use guidance or mention of alternatives like create_rule. The agent must infer usage context from the verb 'List' and the detailed field descriptions.

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. While 'Clear' implies a destructive action, the description omits explicit warnings about data loss, irreversibility, or what happens to existing log entries.

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 exactly two sentences with zero waste: the first defines the action, and the second defines the usage context. It is appropriately front-loaded and sized for a simple parameter-less 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?

Given the tool's simplicity (no parameters, no output schema), the description adequately covers its purpose and usage context. It is slightly incomplete regarding the destructive implications of clearing logs, which would be helpful given the absence of destructiveHint annotations.

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. Per the scoring rules, 0 params equals a baseline score of 4, as there are no parameter semantics to elaborate upon.

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 ('Clear') with a specific resource ('the session log') and distinguishes itself from siblings 'log_read' and 'log_write' by describing a destructive reset action rather than read/write 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?

The second sentence ('Use this at the start of a new task') provides explicit temporal guidance for when to invoke the tool. It lacks explicit 'when-not-to-use' guidance or named alternatives (e.g., contrasting with log_write for appending), preventing a perfect score.

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 burden. It mentions 'current session' implying scope/persistence behavior, but fails to disclose safety characteristics (idempotent?), return format, log size limits, or whether the log includes timestamps/agent actions.

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

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

The description is a single efficient sentence that front-loads the action ('Read'). Every word serves a purpose with no redundancy or filler content.

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

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

Given the tool's simplicity (zero parameters) and lack of output schema, the description provides minimum viable context. However, it omits the return value structure (string, array, or object?), which would be essential for an agent to use the output effectively.

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

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

The tool has zero parameters and 100% schema coverage (vacuously), meeting the baseline expectation for simple tools. No additional parameter context is required or provided.

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

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

The description uses a specific verb ('Read') and resource ('current session log') to clearly define the tool's function. It effectively distinguishes this from siblings like log_write and log_clear by specifying the read-only nature of the operation.

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

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

The phrase 'to see what has been done so far' provides implied usage context (use when checking session history), but lacks explicit when-to-use guidance, exclusions, or comparisons to alternatives like log_write.

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. It explains the purpose (maintaining progress across long operations) but omits mechanical details like whether entries append or overwrite, storage limits, persistence duration, or retrieval methods. Adequate but not rich in behavioral specifics.

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 tightly constructed sentences with zero redundancy: (1) functional definition, (2) usage timing, (3) value proposition. Information density is high with no filler content. Well front-loaded with the core action.

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

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

Appropriate for a single-parameter tool with no output schema. The description covers the operational lifecycle and intent. Could be improved by referencing the sibling log_read tool for retrieval or noting persistence characteristics, but sufficient for correct invocation.

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

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

With 100% schema coverage, the baseline is 3. The description adds valuable semantic context beyond the schema's generic 'Description of what you are doing' by specifying content types: 'plan before starting' versus 'completed step,' guiding the agent on what content to provide in the step parameter.

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

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

The description opens with the specific action 'Write a step to the session log,' clearly identifying the verb (write) and resource (session log). It effectively distinguishes from siblings log_read (reading) and log_clear (clearing) through this explicit action statement.

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 temporal guidance: 'Use this to record your plan before starting, and after each completed step.' This establishes clear when-to-use context for long-running operations. Lacks explicit negative guidance (when not to use) or direct sibling comparison, but the workflow pattern is clearly defined.

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 indicates a state mutation ('mark') but does not disclose idempotency, error handling for invalid UIDs, or whether the operation is destructive. It confirms the toggle nature (read or unread) which is the essential behavioral trait.

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 8-word sentence with no filler. It is front-loaded with the action verb and immediately qualifies scope ('single') and capability ('read or unread'), earning every word.

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

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

Given the low complexity of a single-item state toggle and 100% input schema coverage, the description is functionally complete. The absence of an output schema is acceptable as the operation likely returns simple success/failure, though explicit confirmation of the return type would improve completeness further.

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 all three parameters (uid, seen, mailbox) fully documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, meeting the baseline expectation for high-coverage schemas.

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 'Mark' with clear resource 'single email' and states both possible states ('read or unread'). The word 'single' effectively distinguishes it from the 'bulk_mark_read' and 'bulk_mark_unread' siblings without explicitly naming 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?

The description implies usage through the 'single' keyword (suggesting individual vs. batch operations) but provides no explicit guidance on when to choose this over 'bulk_mark_read'/'bulk_mark_unread' or other alternatives. 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.