EPST

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

Annotations already declare destructiveHint=true and idempotentHint=false, and the description adds specifics: it cancels only recipients that haven't begun submission, returns what was cancelled, and cannot recall already-submitted mail. No contradiction with annotations; the description provides additional behavioral context beyond the structured fields.

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

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

Two concise sentences that front-load the action and include the key limitation. No redundant information.

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

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

The description covers the action, scope, limitation, and return value. Combined with the schema and annotations, it provides sufficient context for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, with the requestId parameter already described as an EPST send request UUID. The description doesn't add any additional parameter semantics, but since the schema fully covers it, a baseline of 3 is appropriate.

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

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

The description clearly states the tool cancels recipients that have not begun submission, specifying the verb and resource. It also distinguishes from recalling already-submitted mail, which helps differentiate from other send-related tools.

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

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

The description implies usage when you need to stop a send before it goes out, and explicitly notes that already-submitted mail cannot be recalled. However, it doesn't name alternative tools or provide explicit 'use this instead of' guidance, though the sibling context provides some context.

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

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

The description explicitly claims idempotency ('Repeating the same operation does not create another folder'), but the annotations declare idempotentHint=false, which directly contradicts this. This is a serious inconsistency that could mislead an agent. Additionally, no other behavioral traits (permissions, error handling, etc.) are disclosed, and with no other annotations to cover the burden, this is a significant failure.

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

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

The description is two sentences long and front-loads the core action first. The second sentence clarifies a key behavior (no duplicate folders). Every word earns its place, and there is no filler. It is optimally concise for the purpose.

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

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

Given that this is a mutation tool with three required parameters and an output schema, the description is under-specified. The contradiction about idempotency creates confusion about expected behavior. It doesn't mention what happens if the folder already exists, what the response contains (though output schema exists), or any required permissions or mailbox validation. The tool's complexity is moderate, but the description leaves critical behavioral questions unanswered, especially the idempotency mismatch.

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 covers all three parameters with descriptions (100% coverage), so the schema already documents each parameter's meaning. The description adds no extra parameter-level detail beyond the schema, so the baseline 3 is appropriate. The description's reference to 'named folder' aligns with the folder parameter but doesn't add new information.

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

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

The description states a specific action ('Create a named folder') and the scope ('in one mailbox'), which is clear and unambiguous. It also distinguishes the tool from siblings by focusing on folder creation rather than message operations. No ambiguity about what resource is affected.

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

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

The description clearly states the action and the target ('in one mailbox'), implying it should be used for creating folders. There are no sibling tools for folder creation, so explicit alternative routing isn't needed. However, it doesn't mention prerequisites like mailbox existence or when not to use it, but given the context, this is a minor 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?

The description adds the behavioral constraint 'Never changes the account domain,' which is valuable beyond the annotations. However, it doesn't elaborate on other behaviors such as idempotency (despite the idempotencyKey), what happens if the mailbox already exists, or any side effects beyond the domain constraint. With annotations covering safety hints, this is adequate but not rich.

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

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

The description is two sentences with zero waste. It front-loads the primary action and adds a critical constraint in the second sentence. No irrelevant details are included.

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

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

The description covers both operational modes (create and resume) and the domain constraint. The schema fully documents the parameters, and an output schema exists to explain return values. Given the tool's simplicity and the richness of the schema, nothing essential is missing.

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

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

The input schema provides detailed descriptions for all parameters (localPart, displayName, idempotencyKey, mailboxId), and the schema coverage is 100%. The tool description does not add any additional parameter semantics beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool creates or resumes a mailbox in the account domain, with the explicit constraint that it never changes the account domain. This distinguishes it from other mail-related tools like send_email or create_folder, making its purpose unambiguous.

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

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

The description provides clear context on when to use this tool: when you need to create or prepare a mailbox or resume a pending one. It doesn't explicitly mention alternatives or exclusions, but the purpose is so specific that an agent can infer the appropriate usage without confusion.

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?

Annotations declare destructiveHint: true, so the tool has potential side effects. The description adds a useful behavioral note about attachment handling (original attachments not included by default), which goes beyond annotations. However, it doesn't mention the non-idempotent nature (idempotentHint false) or clarify what the destructive aspect entails, so it provides modest extra 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, zero filler. The core purpose is front-loaded, and the key caveat about attachments is stated immediately after. Every word earns its place, making it efficient and easy to parse.

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

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

Given an output schema exists and the schema fully describes all parameters, the description is largely complete for a forward operation. It covers the main behavioral nuance (attachment handling) not obvious from the schema. However, it does not mention the requirement of at least one recipient (though schema covers it) or the idempotency/retry implications, but those are structured fields. Overall, it's sufficiently complete for the tool's complexity.

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

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

Schema description coverage is 100%, providing a baseline of 3. The description adds extra meaning by explaining that original attachments are excluded unless selected or the original .eml is attached, which directly clarifies the relationship between attachmentIds and attachOriginal parameters beyond their individual schema descriptions. This enriches parameter understanding, justifying a step above baseline.

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

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

The description states a clear verb ('Forward') and resource (email to recipients), distinguishing it from reply_email and send_email by the explicit recipient specification. However, it does not explicitly name the original message context (via messageId) or a sibling alternative, so it's clear but not perfectly differentiated.

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 siblings like reply_email or send_email. The description only states what it does, not when it's the appropriate choice or what differentiates it. Without explicit or implied usage context, an agent may invoke it incorrectly.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the conditional behavior (selecting a mailbox to include folders) and notes that only 'permitted' mailboxes are returned, enriching the behavioral picture without contradicting 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?

Two sentences with no filler. The core purpose is front-loaded, and the conditional behavior is stated in a compact second sentence. 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 output schema and annotations, the description is sufficiently complete for a read-only discovery tool. Pagination and parameter specifics are in the schema, and the conditional folder selection is clearly communicated. Minor terms like 'readiness' are left to the output schema, which is acceptable.

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 each parameter is already documented. The description ties mailboxId and includeFolders together in the conditional, but does not add details beyond what the schema's conditional logic already expresses. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('permitted mailboxes, sending addresses and capabilities'), clearly differentiating it from sibling tools like send_email or search_messages. The second sentence adds the conditional folder selection, making the tool's purpose unmistakable.

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

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

It implies usage as a discovery tool for mail context, but does not explicitly state when to use it over siblings or when not to. No alternatives are named, so the agent must infer its role from context.

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

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

Annotations already cover readOnly, openWorld, idempotent, and destructive hints. The description adds the crucial 'does not mark it as read' behavior, which is not implied by the annotations. It also mentions attachment references, giving an extra expectation about the result. No contradiction exists.

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

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

A single, front-loaded sentence that states the action, the identifier, the attachment note, and the side-effect note. Every clause earns its place, with zero filler.

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

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

For a read-only operation with a rich output schema and safety annotations, the description is nearly complete. It omits explicit pagination details, but bodyCursor is documented in the schema. The non-marking behavior and attachment references add important context. A 4 reflects that it covers essentials without being exhaustive.

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 reinforces the messageId's EPST nature but adds no additional meaning about bodyCursor, bodyFormat, or bodyMaxChars beyond what the schema already explains. It does not need to compensate.

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

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

The description states a clear verb ('Read') with a specific resource ('message') and identifier type ('EPST messageId'). It also adds the attachment references detail and the non-marking behavior, which distinguishes it from read_attachment and update_message siblings. No ambiguity remains.

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 usage context is clear: read a message when you have the EPST messageId. It does not explicitly mention alternatives or when not to use it, but the scope is self-evident and the sibling list does not introduce competing read tools that would require exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds a meaningful behavioral nuance—'Remote acceptance does not prove inbox placement'—which clarifies the semantics of the returned status beyond what annotations provide. This is valuable context for interpreting results.

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

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

The description is two sentences with zero filler. The primary action and resource are front-loaded in the first sentence, and the caveat is placed second, adding essential context without redundancy.

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

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

Given the presence of an output schema (return format is covered there), the single parameter is fully documented in the schema, and annotations carry the read-only/idempotent safety profile, the description provides everything needed for correct invocation and interpretation. The caveat about acceptance vs. delivery adds a subtle but important behavioral expectation that completes the picture.

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

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

The input schema fully describes the requestId parameter, including format (uuid) and a clarifying note about it not being an email address or Message-ID. The description does not add any further parameter-level meaning, so the baseline of 3 applies given 100% 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 a specific verb ('Get') and names the resource ('per-recipient queue and delivery status for a requestId'), making it clear what the tool returns. The caveat about remote acceptance vs. inbox placement further distinguishes it from send-related siblings like send_email or cancel_send, which focus on the send action rather than status.

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

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

The description implies the tool is used after a send request (requestId originates from send_email), but it does not explicitly state when to use it versus alternatives like get_message for content or cancel_send for cancellation. It lacks explicit exclusions or conditions, leaving the usage context to inference.

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?

Beyond the annotations, it discloses an important behavioral trait: the attachment is not immediately usable, but only once its ID is in READY state. It also implies a non-read, stateful operation, consistent with readOnlyHint=false. This readiness behavior is not available from annotations or schema alone.

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 carry all essential information: the verb, the resource, the source categories, and the readiness condition. It is front-loaded with purpose and contains no filler or redundant restatement of schema 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 tool with a rich nested input schema and an output schema, the description covers what an agent must know outside the schema: the types of sources accepted and the need to wait for READY before using the returned attachmentId. No critical operational guidance is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents all parameters and nested source variants. The description only summarizes the three source categories already defined as the oneOf variants, adding no new meaning 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 a specific verb ('Prepare') and resource ('an attachment'), and enumerates the three supported source types: client upload, existing mail attachment, or original .eml. This differentiates it from siblings like read_attachment and send_email by naming the exact input forms.

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

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

The description gives clear context for when to use the tool: when an attachment must be prepared from one of the listed sources. It also adds a key usage condition, 'Use its attachmentId only when READY,' though it does not explicitly contrast with alternative tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a valuable behavioral clarification (these are not IMAP Drafts-folder messages), which helps prevent misuse. It does not discuss pagination or body limits, but these are implied by the schema parameters (cursor, limit, bodyCursor, bodyMaxChars). Given the strong annotation coverage, the description adds sufficient context.

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

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

The description is extremely concise: two sentences, no filler. The primary action is front-loaded in the first sentence, and the clarifying disclaimer is placed second. Every word earns its place, and the structure is ideal for quick scanning by an AI agent.

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

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

The tool has 8 parameters with complex conditional constraints, but the input schema documents all of this thoroughly, and an output schema exists. The description covers the essential behavioral distinction (list vs. read, and non-IMAP). Given the schema richness, the description is adequate—it does not need to explain return values or detailed parameter interactions, as those are in the schema. Nothing critical is missing for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so every parameter has a description in the schema. The tool description adds a note about the dual mode (list vs. read one draft via draftId), which helps understand the conditional logic (e.g., includeBody implies draftId). However, it does not elaborate on parameter usage beyond what the schema states. Per the rubric, with high schema coverage, the baseline is 3, and the description contributes only marginal value.

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

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

The description states a specific verb ('List') and resource ('EPST draft summaries'), with an explicit alternate mode ('filter by draftId to read one draft'). It also provides a clarifying note that these are not IMAP Drafts-folder messages, which removes a common point of confusion. This clearly distinguishes the tool's purpose from related 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 description gives clear context: it is for listing EPST drafts or reading a single draft by ID. It implies the use case but does not explicitly name alternative tools (e.g., get_message) or state when NOT to use this tool. The non-IMAP remark serves as a caution, but there is no direct comparison to sibling tools. This is clear context without explicit exclusions.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, and the description extends this with the guarantee that it never executes attachment content. The phrase 'bounded text preview' and 'authenticated file reference' add useful behavioral detail about preview limits and access modes that annotations alone do not convey.

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

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

The description is two short sentences with no filler; the primary capability appears first and the safety caveat is front-loaded in the opening sentence. Each clause contributes distinct information: access modes, the preview bound, the file-reference form, and the non-execution guarantee.

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 rich input schema, presence of an output schema, and annotations covering read-only/idempotent behavior, the description supplies the missing contextual framing: what the tool returns in each mode and that it never executes content. The oneOf source ambiguity and mode constraints are already fully documented in the schema.

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

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

Schema description coverage is 100%, so the schema already defines source, mode, cursor, and maxChars in detail. The description's mention of a bounded preview maps to maxChars and preview mode, but it does not add parameter syntax or additional semantic meaning 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 opens with a precise verb-resource pairing ('Get attachment metadata...') and enumerates the three output forms: metadata, bounded text preview, or authenticated file reference. It also asserts a safety boundary, 'Never executes attachment content,' which distinguishes the tool from anything that processes or runs attachment payloads.

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 makes the tool's purpose clear enough that an agent can infer when to call it for attachment access, but it does not explicitly state when to prefer this tool over siblings such as get_message or import_attachment. The only exclusionary language is 'Never executes attachment content,' which is a safety boundary rather than a routing rule.

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?

Annotations indicate destructiveHint true and readOnlyHint false, and the description adds valuable behavioral details: the server appends the original message with quoted history, and if the combined body exceeds the limit, REPLY_TOO_LARGE is returned without sending or truncating. This goes beyond the annotations and clarifies side effects and error handling.

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

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

The description is three sentences, tightly written, and front-loaded with the core purpose and recipient logic. Every sentence adds critical information without redundancy. It is concise and well-structured for quick agent comprehension.

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

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

For a tool with 6 parameters and an output schema, the description covers the essential behavioral aspects: recipient selection, body handling, size limit behavior, and the requirement to check recipients. It does not detail the return value, but the output schema likely covers that. It omits explicit mention of attachments, though attachmentIds are in the schema. Overall, it 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?

Schema description coverage is 100%, so parameters are already documented. The description adds some meaning to replyAll (includes original To/Cc) and clarifies that the reply uses Reply-To or sender, which helps with recipient semantics. However, it does not explain idempotencyKey or attachmentIds beyond the schema, so it adds marginal value overall.

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

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

The description clearly states the tool's function: replying to an email using the original Reply-To or sender, with an option to reply all. It distinguishes itself from siblings like forward_email and send_email by specifying the recipient logic. The verb 'reply' and resource 'email' are explicit.

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

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

It provides clear guidance on what to provide (only the new reply) and warns to check recipients before sending. While it doesn't explicitly compare to alternatives like send_email, the context implies this is for replying to an existing message. The mention of size limit and error behavior adds practical usage context.

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

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

Annotations already convey mutating/destructive behavior (readOnlyHint=false, destructiveHint=true), so the description only needs to add context. It adds that the operation does not send and that replacement is revision-gated, which is useful, but it does not explain conflict handling or that the message field is a full replacement.

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 tight sentence with no filler. The core operation is front-loaded, and the revision requirement is stated precisely in the second clause.

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

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

For a destructive tool with a complex oneOf schema and an output schema, the description covers the essential selection decision: create vs. replace and no send. It leaves conflict semantics and idempotency behavior to the schema/annotations, which is acceptable given their detail.

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

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

Schema description coverage is high and every parameter already carries detailed descriptions, so the description does not need to repeat them. It adds no new meaning about parameters, which matches the baseline expectation for a fully documented schema.

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

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

The description states a specific action ('Create or replace a draft') and scopes it with 'without sending', which distinguishes it from send_email and other mail-sending siblings. It is immediately clear what resource is affected and what operation is performed.

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 useful selection context by noting that replacement requires draftId and the current revision, implying creation is for new drafts. However, it does not explicitly name alternatives or state when save_draft should be preferred over list_drafts, send_email, or update_message.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context by noting the tool returns summaries (not full messages) and supports pagination via nextCursor, which is useful beyond the annotations. It also clarifies the query is plain text, reducing ambiguity.

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

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

The description is two sentences with no redundancy: it front-loads the purpose and then adds two actionable usage tips (pagination and query syntax). Every sentence earns its place, and the structure is clean and efficient.

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

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

Given the schema covers all parameters and an output schema exists (not shown but present), the description provides sufficient context for an agent to use pagination correctly and understand query semantics. It doesn't explain cursor constraints (e.g., must use same filters), but the schema's cursor description covers that. For a search tool with rich schema, this description is complete enough.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters. The description adds little to parameter semantics; it only mentions nextCursor for pagination (which is an output field, not a parameter) and reiterates that query is plain text (already in the schema as 'not a search DSL'). Thus, the description provides minimal additional meaning over the schema.

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

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

The description states a specific verb and resource: 'Search message summaries using explicit filters.' It clearly indicates this is a search operation on message summaries, which distinguishes it from get_message (retrieving a single message) or list_drafts (listing drafts). However, it doesn't explicitly name sibling tools or explain when to choose this over them, so it falls short of full differentiation.

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

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

The description gives pagination guidance ('Use nextCursor for more results') and clarifies query format ('query is plain text, not Gmail search syntax'), which helps an agent use the tool correctly. It does not, however, provide explicit guidance on when to use this tool versus alternatives like list_drafts or get_message, leaving selection to inference.

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?

Annotations already mark this as non-read-only, non-idempotent, and destructive; the description adds meaningful behavioral context by explaining that this enqueues work asynchronously and that an idempotencyKey must be reused on retry. It does not contradict the annotations and helps set agent expectations about delivery timing.

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

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

Two short sentences, with the core action front-loaded and the operational caveats placed immediately after. Every clause earns its place; no redundancy.

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

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

For a two-mode tool with a rich schema and an output schema, the description covers the core modes, async queue behavior, and retry semantics. It leaves sibling routing to other definitions, but an agent has enough to invoke it correctly given the extensive schema documentation.

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 input schema already documents idempotencyKey, mailboxId, message, draftId, and revision. The description adds little beyond the term 'exact draft revision,' which maps to existing schema wording about the current server revision.

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

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

States a specific action and resource: it queues a new message or an exact stored draft revision. This clearly separates it from siblings like reply_email, forward_email, and save_draft, and the second sentence distinguishes queueing from delivery.

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

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

The description gives useful retry guidance and warns that queue acceptance is not delivery, but it never explicitly says when to prefer this over reply_email, forward_email, or save_draft, nor names alternatives. Usage context is implied by the wording rather than stated as explicit when/when-not 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?

Annotations include readOnlyHint:false, destructiveHint:true, idempotentHint:false. The description adds that it 'never permanently deletes mail', which clarifies the destructiveHint is limited to non-permanent destructive actions (moving to trash, modifying flags). This adds useful context beyond annotations. It also implies multiple operations are possible but doesn't detail side effects like folder required existence (exact folder name is in schema). Overall, good supplemental 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, front-loaded with the core purpose and operations, followed by a safety guarantee. No fluff, every word earns its place. The structure is concise and informative.

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

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

The tool has nested operations, 100% schema coverage, and an output schema (though not shown, its presence reduces need for description). The description covers the essence: multiple mutations, never permanent deletion. It does not mention idempotency or key requirements, but these are well-documented in the schema (idempotencyKey description). For an agent selecting and invoking correctly, the description is sufficient. A small gap: it doesn't state that folder must already exist for move/copy, but that's in the schema. Overall, nearly complete.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description provides top-level guidance: 'Set message flags, move, copy or trash a message' which maps to the operation object. It also highlights 'Choose one operation' summarizing the oneOf constraint. The nested object descriptions are thorough, but the description adds the high-level intent that helps an agent grasp the operation's purpose. This exceeds the baseline.

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

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

The description states a specific set of operations (set flags, move, copy, trash) with a clear resource (message) and explicitly notes it never permanently deletes mail. It distinguishes itself from siblings like send_email or forward_email by focusing on message mutations. Although it doesn't name a sibling, the verb+resource+operation list is specific and unambiguous.

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

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

The description clarifies that it modifies messages (flags, move, copy, trash) and explicitly excludes permanent deletion. It implies it's for post-delivery message management, but does not explicitly say when to use this vs. alternatives like get_message or save_draft. The lack of explicit exclusion of non-mutation operations is a minor gap; still, the intended use case is clear.

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