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

Annotations already disclose that this is a mutating (non-read-only) operation and not destructive. The description adds that the tool returns the inbox details and email address, which is useful, but it does not discuss potential side effects like inbox creation limits or whether tags affect retrieval. The description complements the annotations without contradicting them.

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

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

The description is concise, with a front-loaded purpose statement followed by a compact parameter reference. No unnecessary information is included, and the structure is 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?

For a simple create tool with two optional parameters and an output schema, the description covers the main purpose and parameter roles. It mentions the return value but omits potential edge cases like duplicate display names or the relationship to list_inboxes, but these are not critical for a basic invocation.

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

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

Despite 0% schema description coverage, the description's Args section gives meaning to both parameters: display_name as a friendly name and tags as comma-separated, with examples. This compensates well for the sparse schema, though it does not elaborate on how tags are used downstream.

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 'Create' and the resource 'new email inbox', distinguishing it from sibling tools like list_inboxes and delete_inbox. The mention of returning inbox details adds specificity about what the tool accomplishes.

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 for creating inboxes but does not explicitly state when to use it versus alternatives such as list_inboxes or delete_inbox. No exclusions or alternative tool references are provided, so usage is inferred rather than explicit.

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

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

The description adds that deleting an inbox also permanently removes all its messages, which is a behavioral detail beyond the destructiveHint annotation. This provides useful context about scope of destruction.

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: a single sentence and an args block, with no unnecessary information. It is well-structured and front-loaded.

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

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

For a simple one-parameter tool with an output schema and annotations covering destructiveness, the description provides enough context. It explains the action and parameter, and the output schema handles return value details.

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

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

Schema description coverage is 0%, but the description explicitly defines inbox_id as 'The inbox ID to delete', adding meaningful semantics beyond the schema's bare title. This compensates well for the coverage gap.

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

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

The description clearly states the tool deletes an inbox and all its messages, which is a specific verb+resource+scope. This distinguishes it from sibling tools like create_inbox and list_inboxes.

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

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

No explicit when-to-use or alternative guidance is given, but the usage is implied by the name and description. It lacks any exclusion criteria or context about when not to use it.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, etc., but the description adds no additional behavioral context. It does not disclose side effects (e.g., sending an email), permission requirements, or any other behavioral traits beyond the annotations. Without this, the agent cannot anticipate consequences of the mutation.

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

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

The description is extremely concise, starting with a one-sentence purpose followed by a structured Args block. Every word earns its place, and the format is easy to parse. It is appropriately sized for the tool's simplicity.

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

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

With annotations and an existing output schema, the description is partially complete. It covers parameters well but lacks usage guidance, prerequisites, and behavioral consequences. For a simple tool, this is adequate but leaves gaps about when to use it and what happens when invoked.

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

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

The input schema has 0% description coverage, but the description fully compensates by explaining every parameter: inbox_id, message_id, to (with comma-separated multiple recipients), and body (optional). This adds significant meaning beyond the raw schema, making it easy for the agent to understand what each argument does.

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 ('Forward a message') and the resource ('to new recipients'), which is a specific verb+resource combination. It distinguishes from reply_to_message by emphasizing new recipients, but does not explicitly differentiate from send_email, so it is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like send_email or reply_to_message. There is no mention of exclusions, prerequisites, or cases where another tool would be more appropriate, leaving the agent without 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 declare readOnly, idempotent, and non-destructive behavior. The description adds valuable context by specifying the exact metrics returned (inboxes, sent/received emails, plan limits), which helps the agent understand what to expect beyond the generic annotation hints.

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

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

The description is a single, front-loaded sentence that directly states the purpose and scope. It contains no fluff or redundancy — every word contributes meaning.

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

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

Given the simplicity of the tool (no parameters, output schema present), the description is complete. It covers the core purpose and the categories of metrics returned, which is sufficient for an agent to select and 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?

This tool has zero parameters, so the baseline score is 4. The description adds no parameter-specific details because none exist. The schema already reflects this completely (100% 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 the specific verb 'Get' with the resource 'account usage metrics' and enumerates the contents (inboxes, emails sent/received, plan limits). This clearly distinguishes it from sibling tools like list_inboxes or send_email, as none of those cover account-level usage metrics.

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: when account usage or plan limits are needed. It does not explicitly name alternatives or state when not to use it, but the sibling tools perform distinctly different functions, making the use case obvious.

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 useful behavioral context beyond the annotations: it explicitly says the tool 'waits for the next new inbound email' and 'returns the auto-extracted verification code (and any magic link).' This clarifies that it blocks and performs extraction, which the readOnly/idempotent hints do not convey. It lacks details on timeout failure behavior, but the output schema likely covers return values.

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 appropriately sized: a brief introduction, a clarifying sentence, a use-case mention, and a structured Args block. It is front-loaded with the core purpose and avoids fluff or repetition.

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

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

For a tool with three parameters and an output schema, the description covers the main operational aspects: purpose, parameters, and general behavior (waiting and extracting). It does not explicitly state what happens on timeout or whether the email is consumed, but given the simplicity of the tool and the presence of an output schema, the description is nearly complete. Minor gaps remain.

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?

Although the schema has no parameter descriptions (0% coverage), the description includes an Args section that clearly explains each parameter: inbox_id ('The inbox to watch'), from_contains ('Only match senders containing this text'), and timeout_seconds ('Max seconds to wait, default 60'). This fully compensates for the schema gap.

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

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

The description clearly states the tool's function: 'Wait for a verification/OTP email and return the extracted code.' It specifies a unique action (waiting and extracting) and highlights the magic link, distinguishing it from sibling tools like wait_for_email or get_verification_link.

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 it: 'Perfect for autonomous sign-ups.' It implies the tool is for retrieving a code from an incoming email, which differentiates it from generic email reading or waiting tools. However, it doesn't explicitly state when not to use it or mention alternatives by name.

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

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

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds behavioral details beyond annotations, such as waiting for an email, optionally filtering by sender, and a timeout in seconds. It does not mention error behavior or what happens on timeout, but the core behavior is transparent.

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

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

The description starts with a one-sentence purpose, followed by a compact, well-formatted Args list. Every sentence is informative; there is no fluff or repetition of schema metadata.

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 an output schema, so return format is covered. The description gives the essential purpose and parameter semantics, but it does not address error cases or how it integrates with sibling tools. It is complete enough for a straightforward waiting-and-extraction utility.

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

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

Schema description coverage is 0%, so the description must compensate. It does so excellently by explaining each parameter in plain language: inbox_id as the inbox to watch, from_contains as an optional sender filter, and timeout_seconds as max wait time. This adds meaning beyond the raw schema.

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

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

The description clearly states the tool waits for an email and returns the extracted magic link or verification URL. It is specific about the verb ('return') and resource ('magic link / verification URL'), and it distinguishes from siblings like get_verification_code, which extracts a code rather than a link.

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

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

The description provides clear context: it is used when you need to wait for an incoming email and extract a verification link from it. It does not explicitly mention alternatives or exclusions, but the purpose is obvious enough to know when to use it.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds the behavioral detail that it lists 'all' inboxes (i.e., comprehensive scope) and explains the limit parameter's effect, which goes beyond the structured annotations without contradicting them.

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, front-loaded with the primary action, and includes a formatted args section. Every word earns its place, with no redundancy or fluff.

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 list tool with one optional parameter, an output schema, and strong annotations, the description fully covers the essential behavior (what it lists, scope, limit semantics). No further context is needed.

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

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

Schema coverage is 0%, but the description compensates by explaining 'limit: Maximum number of inboxes to return (default 20)'. This clarifies that the parameter is an optional cap, adding meaning beyond the raw schema default. However, it does not describe any other parameters or edge cases.

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 'List all email inboxes in the account' with a specific verb ('List'), resource ('inboxes'), and scoping ('account'). It distinguishes from siblings like list_threads and read_messages by explicitly focusing on inboxes.

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 purpose is immediately clear: use this when you need to enumerate email inboxes. While no explicit alternatives or exclusions are mentioned, the account-wide scope and the sibling tool names (e.g., list_threads) provide implicit context for 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?

Annotations already declare readOnlyHint and idempotentHint, but the description adds no behavioral context beyond restating the inbox_id parameter. It does not disclose ordering, pagination, or whether threads include message previews, so the description itself provides almost no extra transparency.

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

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

The description is compact and free of fluff. It consists of a single clear purpose sentence and a minimal args block, both of which earn their place 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?

With only two parameters, an output schema available, and strong annotations, the description covers the essentials. It lacks details on result ordering or limit behavior, but that is a minor gap for a straightforward list 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 Args section explicitly explains each parameter: 'inbox_id: The inbox to list threads for' and 'limit: Maximum number of threads to return (default 10)'. This is valuable because the input schema has no descriptions, so the description fully compensates for the schema's 0% 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 the specific verb 'List' with resource 'conversation threads' and scope 'in an inbox', clearly distinguishing it from siblings like list_inboxes and read_thread. It states exactly what the tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives such as read_thread or read_messages. There is no mention of when not to use it, prerequisites, or intended workflow 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 declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds that the tool returns 'full body content', which tells the agent what to expect in the response. No contradiction 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?

The description is brief and front-loaded with the purpose. The Args block is structured and compact, with every sentence providing necessary information and no superfluous 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 (2 required params, no nested objects), the presence of an output schema, and rich annotations, the description covers the essential behavioral and parameter information. It could optionally mention error behavior, but that is not necessary for straightforward 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?

The input schema has no descriptions for properties (0% schema coverage), but the description's Args section compensates by explaining inbox_id as 'the inbox containing the message' and message_id as 'the message ID to read'. This adds meaningful context beyond the schema's bare titles.

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: 'Read a single message with full body content.' This uses a specific verb (read), resource (message), and scope (single, full body), which distinguishes it from sibling tools like read_messages that likely handle multiple 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 description explicitly indicates usage for a single message as opposed to multiple or thread reads. While it doesn't name alternative tools or provide exclusions, the context is unambiguous enough for an agent to select this tool when a single full message is needed.

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, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds the notion of 'recent' and inbox scoping, but does not clarify ordering, pagination, or whether it returns only unread messages. Given the annotations, the behavioral context is adequate but minimal.

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 short, front-loaded sentence followed by a minimal Args list. Every sentence provides value with no redundancy, making it appropriately concise.

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 list operation with an output schema and robust annotations, the description covers the essential behavior. The ambiguity of 'recent' and lack of detail on message ordering or filtering are minor gaps, but the tool is simple enough that the description is largely complete.

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

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

Schema description coverage is 0%, so the description's Args section compensates by explaining inbox_id as 'the inbox to read from' and limit as 'maximum number of messages to return (default 10)'. This clarifies the parameters beyond the schema, though it could further specify the expected format of inbox_id (e.g., an ID from list_inboxes).

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 'Read recent messages in an inbox' uses a specific verb and resource, clearly indicating it lists messages. It is distinguishable from sibling tools like 'read_message' (singular) and 'list_threads' by focusing on messages rather than threads or individual reads.

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

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

The description provides no explicit guidance on when to use this tool over alternatives like 'read_message' or 'list_threads'. There is no mention of exclusions or context where another tool would be preferred, leaving the agent to infer usage from the tool's name and siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds the scope 'all messages' and clarifies the parameter roles, but does not disclose additional behavioral traits such as ordering, pagination, or potential errors. This is a minimal increment over annotations.

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

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

The description is extremely concise, with a one-line purpose statement followed by a compact Args block. Every sentence earns its place, and the main action is front-loaded.

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

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

This is a simple read-only tool with a clear purpose, adequate parameter descriptions, and annotations covering safety. The presence of an output schema means return values need not be described. The description is sufficiently complete for an agent to invoke the tool correctly, aside from usage guidance which is covered elsewhere.

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

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

The description provides brief semantic meaning for each parameter (inbox_id is 'the inbox containing the thread', thread_id is 'the thread ID to read'), which goes beyond the bare parameter titles in the schema. However, this is still basic and does not elaborate on formats or constraints.

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

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

The description clearly states 'Read all messages in a conversation thread' with a specific verb, resource, and scope. This distinguishes it from sibling tools like read_message (singular) and read_messages (plural) by explicitly targeting threads.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites (e.g., needing a thread ID from list_threads), or contrast with read_message/read_messages.

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 safety (non-read-only, non-destructive, non-idempotent). The description adds useful behavioral details: threading headers are set automatically and the body is plain text. This goes beyond annotations, though it doesn't discuss side effects like sending or auth.

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

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

The description is concise, with a brief first sentence and a structured Args block. Every sentence is useful, though the first sentence 'Reply to a message' is somewhat redundant with the tool name. 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?

The description covers the core purpose and all parameters, but lacks explicit guidance on tool selection among siblings (send/forward) and any behavioral caveats (e.g., sending limitations, whether attachments are allowed). Given the presence of an output schema and annotations, it's adequate 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?

The schema has 0% description coverage, but the description includes an Args block that explains each parameter (inbox_id, message_id, body) clearly. This fully compensates for the missing schema descriptions and adds meaningful context.

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

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

The description clearly states the action ('Reply to a message') and adds a distinguishing detail ('Threading headers are set automatically'). However, it does not explicitly compare to sibling tools like send_email or forward_message, so it's clear but not fully 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?

Usage is implied by the name and first sentence: you reply to an existing message. But there is no explicit guidance on when to use this over send_email or forward_message, nor any exclusions or prerequisites. This is implied usage, not explicit 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?

The annotations already indicate that this is a non-read-only, non-idempotent, non-destructive operation. The description adds no extra behavioral context, such as delivery guarantees, authentication requirements, or side effects, beyond the basic fact that it sends an email.

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 compact and well-structured: a single clear sentence followed by a concise parameter list. Every element adds value, with no wasted words 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?

Despite having an output schema, the description omits important contextual details: when to use it (vs reply/forward), prerequisites (e.g., inbox existence), and operational behavior (e.g., immediate sending or error handling). For a 6-parameter mutation tool, this is a significant gap.

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

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

The Args section adds meaningful explanations across all parameters, noting comma-separated recipients, optional cc/bcc, and plain-text body. This compensates for the schema's 0% description coverage, giving the agent enough to correctly invoke the tool.

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

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

The description 'Send an email from an inbox' clearly states the action (send), the resource (email), and the source (inbox). It is straightforward and understandable, though it does not explicitly differentiate from sibling tools like reply_to_message or forward_message.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for composing a new email, as opposed to replying or forwarding, nor does it state any prerequisites (e.g., an existing inbox).

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 (readOnlyHint, openWorldHint, idempotentHint), the description adds essential behavioral context: it blocks until an email arrives, and only emails arriving after the call are considered. This stateful waiting behavior is not captured by annotations and is critical for correct usage. The timeout_seconds parameter is also explained as 'Max seconds to wait,' giving the agent a clear expectation of the blocking behavior.

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

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

The description is concise and well-structured: a one-sentence purpose, a usage note, and a compact parameter list. Every sentence adds value; there is no fluff or repetition. The front-loaded purpose statement ensures the agent immediately understands the 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?

With an output schema present (to explain return values) and annotations covering safety, the description provides all necessary context: purpose, usage scenario, parameter semantics, and the critical 'new arrivals only' behavior. It covers the blocking timeout behavior via the parameter description. No gaps are evident for a tool of this complexity.

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

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

The input schema has no descriptions for any parameters (0% coverage). The description fills this gap entirely with an 'Args' section that explains each parameter: inbox_id, from_contains, subject_contains, and timeout_seconds. This provides complete semantic meaning beyond the raw schema fields, enabling correct parameter usage.

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

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

The description opens with a specific verb+resource: 'Block until a NEW inbound email arrives in the inbox, then return it.' This clearly distinguishes it from sibling tools like read_messages or list_threads, which read existing content, by emphasizing 'NEW' arrivals. It also states the blocking nature, leaving no ambiguity about the tool's function.

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

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

The description explicitly states when to use the tool: 'Use for signup/verification flows: trigger the action that sends the email, then call this to receive it.' It also provides a key exclusion: 'Only emails arriving after this call count,' which prevents confusion with read_messages when checking for existing messages. This is clear, actionable guidance.

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