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

Annotations already indicate readOnlyHint=true, so the description doesn't need to restate that. However, it adds substantial behavioral context, such as billing details (per-provisioned-mailbox pricing), the meaning of activationState as the 'HONEST send state', and conditions for teardown. This goes well beyond the 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 dense but efficient, using a concise introductory sentence listing key fields, then brief elaborations on billing and activationState. Every sentence serves a purpose, and the structure is clear with 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?

With no output schema, the description fully covers the return data, including fields like recentActions[], teardown, and detailed activationState interpretations. It is complete for a read-only account overview, leaving no ambiguity about what the tool provides.

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 no parameters, so description is not needed for parameter semantics. According to guidelines, 0 parameters earns a baseline of 4. The description does not add anything about parameters because none exist, which 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 it provides an 'Account overview' and lists specific fields (brand, plan, status, etc.). It also differentiates from sibling tools by noting that 'metrics' should be used for counts and 'infrastructure_status' for per-mailbox health, making the purpose unambiguous and distinct.

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 guides when to use this tool: it advises trusting activationState over 'sent' counts and directs users to other tools for specific needs ('Use metrics for counts, infrastructure_status for per-mailbox health'). It also explains the meanings of activationState values, providing clear context for decision-making.

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 annotation only provides destructiveHint=false, so the description carries the burden of explaining the tool's side effect. It does so well: it sets readAt, stops the message surfacing as unacked, is idempotent, and returns 404 for invalid IDs. No contradiction exists, though it stops short of discussing any broader state or rate-limit implications.

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 slightly longer than strictly necessary, but every sentence adds actionable information: purpose, exclusivity vs reading/listing, idempotence, and error behavior. The core how-to is front-loaded and the extra details support reliable calling.

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 ack operation with no output schema, this description is complete. It tells the agent what the effect is, confirms repeated calls are harmless, gives the error condition, and notes the ID provenance. No essential behavioral information 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 schema description fully covers the only parameter, messageId, including where the ID originates. The description repeats that same source rather than adding new semantic detail, but because schema coverage is 100%, the parameter is already well documented and no further compensation is needed.

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 ('Acknowledge a message by id'), the resource ('message'), and the effect ('sets it read so it stops surfacing as unacked'). It also distinguishes this tool from message-reading/list operations by emphasizing that it is the only thing that sets readAt.

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 explicitly tells the agent when to use this tool: after getting message IDs from list_messages or infrastructure_status, when intentionally marking a message as read. It also clarifies when not to expect side effects via idempotence, and what happens with a nonexistent ID. This gives clear usage context without assuming 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?

Annotations already declare readOnlyHint=true. Description adds behavioral context: cursor-pagination, merged feed, response structure { items[], nextCursor }, and item fields. No contradictions. Adds value beyond 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?

Concise single paragraph front-loaded with purpose, then details on pagination, item structure, and filters. Every sentence earns its place. Slightly dense but 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?

Despite no output schema, the description fully specifies the return structure, pagination, filters, and default/max values. Covers all needed context for a read-only feed tool with simple parameters.

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%. Description mentions filters (kind, limit) and defaults/max (50, 200) already in schema. Adds meaning for kind enum values ('event' vs 'deliverability') and cursor usage. Does not fully compensate for missing schema descriptions but adds moderate 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 clearly states it is a 'Unified activity feed' merging campaign events and deliverability actions, and distinguishes itself from sibling 'inbox' tool by noting 'Use inbox for replies only.' The specificity of verb and resource is high.

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

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

Explicitly instructs when to use this tool vs inbox for replies. Provides filter guidance (kind, limit, cursor). Does not mention other sibling tools like get_dashboard, but the context is sufficient for typical 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?

Adds significant detail beyond readOnlyHint annotation: clarifies bounce is HARD only, opens not tracked, and 404 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?

Three efficient sentences covering purpose, input/output format, and explicit usage guidance. No unnecessary words.

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

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

Fully describes a simple read operation: input, output fields, error case, and relationship to sibling tools. No output schema 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 100% with description for campaignId. Description restates that input comes from launch_campaign but adds no new meaning beyond 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?

Description states 'Outcome counts for ONE campaign' - specific verb and resource. Clearly distinguishes from sibling tools by naming 'metrics' and 'list_campaigns' as 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?

Explicitly says when to use this tool (single campaign results) and alternatives (metrics for account-wide, list_campaigns for all). Also specifies input source and 404 handling.

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 behavioral context beyond the destructiveHint annotation, such as running a 'pre-flight live-infra scan + abuse gate + reputation ladder' and returning billing projections. It does not contradict the annotation and enriches understanding of side effects.

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

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

The description is lengthy but well-structured with action identifiers and clear sentences. It is as concise as possible given the tool's complexity, front-loading the overall purpose before detailing each 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?

The description covers all actions, parameter dependencies, billing projection behavior, and special flags like quoteOnly. With no output schema, it provides sufficient context for an AI agent to invoke the tool correctly across all scenarios.

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 90% schema description coverage, the baseline is 3. The description adds meaning by explaining each parameter's role per action (e.g., 'acknowledge_consent needs id + acknowledged:true — REQUIRED before a primary domain can proceed past pending_consent'), going 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 tool is for registering or advancing BYO domain/mailbox intake, referencing SPEC.md §20. It lists five distinct actions with specific verbs and resources, effectively distinguishing each sub-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 description provides detailed guidance on when to use each action, including required parameters and context (e.g., 'register needs domain + domainRelationship', 'poll_dns needs id'). It implies a logical order but does not explicitly compare against sibling tools or state when not to use this tool.

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

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

Beyond the 'destructiveHint' annotation, the description discloses the compare-and-swap behavior for update: a stale rev returns '{ currentRev, currentLayout }' to rebase and retry. Does not mention rate limits or auth, but the conflict resolution is a key 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?

Efficiently written in one paragraph with no filler. Front-loaded with the main purpose. Could be improved with bullet points for the actions, but is very compact 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?

Given the absence of an output schema, the description explains the conflict response for stale revisions, which is critical. No description of success return values, but the tool's complexity and the CAS behavior are well-covered.

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?

Adds action-specific required parameters (e.g., create needs name+layout, update needs id+rev+layout) and explains the rev parameter's CAS semantics. The schema covers 83% of parameters, but the description reinforces and provides context beyond the 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?

Begins with 'Write a saved dashboard view,' clearly identifying the verb and resource. Lists four specific actions (create, update, promote, delete), and distinguishes from sibling 'get_dashboard' which is read-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?

Explicitly instructs to 'Read the current rev+layout via get_dashboard first' before update. Explains when each action is appropriate (create needs name+layout, update needs id+rev+layout, etc.) and details the CAS conflict handling for update.

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 goes beyond the destructiveHint annotation by disclosing that create/rotate return the HMAC secret only once, that URLs must be public HTTPS with private/metadata IPs rejected, that deliveries are signed with HMAC-SHA256, and that active:true can re-enable an auto-disabled subscription. These behavioral details are valuable and not available in the annotations or 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?

The description is dense but every sentence carries unique high-value information. The front-loaded purpose phrase is followed by compact action-specific syntax, and the security details are appended without unnecessary prose. It is long enough to be complete but not bloated.

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 multi-action mutation tool with no output schema, the description covers the core behaviors: required inputs per action, URL validation, secret rotation and one-time return, and the delivery signature. The only notable gap is that the success/return behavior for update and delete beyond the 'one changed field' is not described, but this is minor given 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 coverage is 86%, so the schema already documents most parameters. The description adds useful semantic relationships: id is required only for update/delete, url + eventTypes are the create prerequisites, update takes exactly one changed field, and secret on update rotates the signing secret. This additions help the agent assemble the correct action-specific parameter sets.

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 announces 'Manage an outbound webhook subscription' and then enumerates the three concrete actions: create, update, and delete. This clearly distinguishes the tool from siblings like get_webhooks, which exists for reading subscriptions rather than mutating 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 gives explicit guidance for when to use each action: create needs URL + eventTypes, update needs id + one changed field, delete needs id. It also clarifies edge cases like re-enabling via active:true, but it does not explicitly mention 'use get_webhooks to view existing webhooks' as an alternative, so it misses an opportunity for a stronger routing cue.

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 provide only destructiveHint=false and a title, so the description must carry the behavioral burden — and it does: it discloses that a ticket is filed and an operator notified, the dedupe contract, rate limits with retryAfter, 401 rejection for admin-terminated accounts, the ops-email throttle bypass, and that replies arrive as a message on this account (with no separate reply-fetch call). Nothing contradict the 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?

Long (roughly 350 words), but the purpose is front-loaded in the first sentence, which is exactly where agents make route decisions. The dedupe section is the one place that runs, passing a few sentences to land 'text match, not intent match' — it could be tightened. Still, every sentence carries non-redundant behavioral detail; there is no filler.

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

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

Even with no output schema, the description supplies the return shape ({ ticketId, note, deduplicated }), the dedupe idempotency behavior, the rate-limit response shape (429 with state that provides retryAfter), the auth-edge exception, the account-state compatibility, and the reply-delivery mechanism. For an agent need to call this correctly, nothing is left unstated.

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 fully owns parameter semantics. It explains body as the message text (1-2000 chars), urgency as the 'normal' vs 'needs_human' values with default, and, crucially, the escape semantics of 'needs_human' always filing a new ticket even within the dedupe window. The explanation also reveals that both body and urgency together form the dedupe key, which is well beyond what the schema reveals.

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?

Opens with a precise verb+resource, 'Reach a human operator', and immediately narrows the purpose as the catch-all for what list_messages and infrastructure_status cannot answer, with concrete example scenarios (billing, stuck vendor, account-level ask). It is instantly distinguishable from the sibling set even without opening any schema.

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

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

Names the alternatives (list_messages / infrastructure_status) and states the conditions that route to this tool: issues those tools cannot answer, and specifically the 'why is my account suspended?' case. It also gives clear when-not-to-send guidance: the text-match dedupe means a genuine new ask with identical wording must be rewritten or escalated.

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 readOnlyHint=true; description adds rich behavioral details: lists output fields per mode, explains status progression, and notes that configure_byo_domain is for mutation. No contradictions.

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?

Five sentences, front-loaded with main action, then specifics. Every sentence adds value without redundancy.

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

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

For a simple 1-parameter tool with no output schema, the description fully covers behavior, output structure, status progression, and sibling tool linkage.

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 for 'id' parameter; description goes beyond schema by explaining the effect of omitting vs providing id, and enumerates additional returned fields when id is 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?

Clearly states it lists BYO domains or gets full intake detail for a specific domain. Distinguishes between two modes and differentiates from sibling tool 'configure_byo_domain'.

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 tells when to omit 'id' vs pass it, and directs users to 'configure_byo_domain' for registration or advancement. No ambiguity.

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, so description's reading behavior is consistent. It adds value by explaining the rev role and that views are both agent- and human-editable, going beyond 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?

Description is three concise sentences: core purpose, mode behavior, and additional context. No unnecessary words, front-loaded with key 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?

With only one optional parameter and no output schema, the description fully explains return structures for both modes and connects to sibling tool, providing complete 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 already describes id parameter well, but description adds meaning by specifying the exact fields returned in each mode and how rev connects to configure_dashboard, enhancing 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?

Description clearly states 'Read saved dashboard views' and distinguishes between two modes: listing all with no id, and retrieving full layout with id. It contrasts with sibling tool configure_dashboard, making 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?

Explicitly tells when to use each mode ('No id → list all', 'With id → that view's full layout + rev') and advises to write views with configure_dashboard, providing clear alternative.

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 reveals that secrets are never returned on reads, a behavioral trait beyond the 'readOnlyHint' annotation. This is consistent with the annotation and adds important context for the agent.

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 yet comprehensive, covering both use cases and a critical note about secrets without unnecessary verbosity. It is well-structured with front-loaded main 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?

The description details return shapes for both cases, compensating for the lack of an output schema. It lacks information on pagination or limits, but the simplicity of the tool makes this 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?

The schema description coverage is 100%, and the parameter description already explains the id behavior. The tool description does not add additional meaning beyond the schema, meeting the baseline expectation.

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 lists webhook subscriptions, with distinct behaviors for omitting or providing an id. It specifies the return format for each case, making the 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 explains when to use the id parameter versus omitting it, providing clear usage patterns. It does not explicitly mention when not to use this tool or alternatives among siblings, but the guidance is sufficient.

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. The description adds value by detailing pagination behavior and the structure of return data (threads[], nextCursor, fields). 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 extremely concise: two sentences plus a filter list and an alternative tip. Every sentence adds value, and the most important information (purpose, pagination, key filters) 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?

Given no output schema, the description compensates by specifying return structure and fields. It covers all major filters and provides a usage pointer to a sibling. Missing details like error handling or ordering, but still adequate for a read-only paginated list tool.

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

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

Schema description coverage is 0%, but the description explains the meaning of 6 out of 8 parameters (mailbox, campaign, label, read, includeNonreply, archived) including the enum options for archived and default for includeNonreply. Two parameters (limit, cursor) are only implicitly mentioned via pagination context, which is acceptable.

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

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

The description clearly states the tool returns a unified reply inbox across mailboxes, specifies cursor-paginated output with fields, and distinguishes from sibling 'thread' by telling to use that for one thread's history.

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 lists available filters and explicitly mentions an alternative tool ('Use thread for one thread's history'), providing clear context on when to use this tool. However, it does not explicitly state when not to use it.

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

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

Beyond the readOnlyHint annotation, it discloses critical behavioral details: sendReady is not a send gate, top-level sendReady is an AND across mailboxes, vendor-reported scores can be null and are not first-party, vendor-pool warmup is invisible, and reading messages here does not mark them read. It also explains severity semantics and retry outcomes.

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 information-dense and front-loaded, with nearly every sentence contributing necessary behavioral context. It loses one point because the message-ordering and 5-message cap points are repeated, making the text more verbose and harder to scan than needed.

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 no output schema, the description carries the full burden of explaining return values, and it does so thoroughly: mailbox fields, severity levels, nextSteps pointer, message-capping behavior, and retry semantics. It is complete for an agent to understand what this call returns and how to act on it.

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

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

The tool has zero parameters and the schema covers that completely, so the description correctly spends no effort on parameter documentation. For a 0-parameter tool, the baseline is 4, and the description enriches the output semantics that matter instead.

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 opening line states a specific purpose: exposing warmup and provisioning progress per mailbox. It enumerates the exact returned fields and distinguishes itself from account-level rollups and message history 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 explicitly names alternatives and when to use them: list_messages for full history, ack_message for marking messages read, account/metrics for account-wide rollups, and setup_infrastructure for the nextSteps shape. It also directs when to poll this tool alongside mailbox fields.

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?

Describes the mutation behavior (set or clear, with null to clear) and is consistent with destructiveHint=false. Adds value beyond annotations by explaining how to clear a label.

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 purpose, no wasted words. Efficiently conveys all necessary 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 simplicity of the tool (2 params, no output schema), the description provides enough context: it links to dashboard chips, explains clearing, and notes filterability. No gaps.

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

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

Schema coverage is 50%; the description adds meaning for the 'label' parameter by explaining how to clear it. The 'threadId' parameter is already described 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 verb 'set or clear' and the resource 'triage LABEL on an inbox thread', and distinguishes it from the sibling tool 'mark' by explaining that a label is a free-form category, not a read flag.

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 differentiation from 'mark' and mentions filterability via inbox's label param. Does not list all alternative tools but gives clear context for when to use this tool.

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

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

Beyond destructiveHint: true, the description reveals real send consequences, duplicate refusal with 409 and a specific error shape, scheduling behavior, suppression of leads, and idempotent replay. This is exactly the behavioral context an agent needs before triggering an external mail operation.

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

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

Every sentence earns its place. The description front-loads the core purpose, then moves to scheduling/suppression, return value, duplicate behavior, and idempotency. The length is justified because sending real email carries significant side effects that the agent must understand.

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 eight parameters, nested objects, no output schema, and a destructive hint, the description is remarkably complete. It covers the return shape, duplicate error handling, idempotency behavior, scheduling semantics, and when to avoid relaunching. No critical information needed to invoke it correctly 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 description enumerates all primary parameters (name, offer, leads, sequence, sendWindow, timezone, stopOnReply) and clarifies the essential idempotencyKey usage. It also adds meaning beyond the schema: 'the platform does not write copy', step fields, and suppressed-lead skipping. It doesn't explain every nested field, but the schema's structure and defaults cover those details.

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 is unambiguous: 'Create and activate a campaign on a lead list' names a specific verb, resource, and scope. It also distinguishes this from sibling tools like list_campaigns or pause by emphasizing that the platform actually sends real mail and does not write copy.

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

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

It gives explicit when-to-use and when-not-to-use guidance: don't relaunch an identical 60-second campaign; check the existing campaign via its campaignId instead. It also explains when it is legitimate to launch again, and instructs to resend the same idempotencyKey when retrying a lost response.

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 the description adds behavioral context (returns list with specific fields, newest first, bulk operation). Could mention limitations like pagination, but not necessary given no parameters.

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, front-loaded with purpose, zero wasted words.

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

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

For a zero-parameter tool with no output schema, the description fully covers what the tool returns, ordering, and provides sibling guidance.

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

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

No parameters exist, and schema coverage is 100% (trivially). Baseline is 4; description does not add parameter info but provides output structure, which is helpful but not required for this dimension.

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 'List every campaign at once' and provides the output structure, clearly distinguishing it from siblings like campaign_results and 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?

It explicitly says when to use (when you need all campaigns) and when not to, offering alternatives: 'Use campaign_results for one campaign's counts, metrics for account-wide totals.'

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 behavioral context beyond the readOnlyHint annotation by specifying cursor-pagination, return structure (leads[], nextCursor), and available filters. 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?

Three concise sentences, front-loaded with purpose, each providing essential information 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 six parameters and no output schema, the description covers purpose, response structure, pagination, and sibling alternatives. It lacks detailed parameter explanations but is otherwise comprehensive for a list tool. Minor gap: no explicit mention of default limit value.

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 0% schema description coverage, the description partially compensates by listing four filter parameters (campaign, interestStatus, suppressed, replied). However, it does not explain the pagination parameters (limit, cursor) beyond mentioning cursor-pagination. Enums are only in schema, not described. Adequate but not exhaustive.

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/export leads' with specific verb and resource, and mentions cursor-pagination, making the purpose immediately obvious. It also differentiates from siblings by referencing update_lead and suppress_lead.

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 this tool: 'This IS the export surface — paginate to dump the full book of business as JSON (no separate CSV endpoint).' It also points to alternatives: 'Use update_lead to write disposition, suppress_lead to opt an address out.'

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

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

The description adds critical behavioral context beyond the readOnlyHint annotation: listing never sets readAt, a null readAt does not mean unseen, and the subtle semantics of 'operator_pending' vs 'terminal' are explicitly explained. This strongly warns the agent against incorrect retry 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 long but densely packed with actionable details: sorting order, message semantics, ack behavior, retry implications, and sibling referencing. Each sentence carries meaningful information, though the paragraph structure is dense enough that it could benefit from a small bit of formatting or highlight separation.

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 list/read tool with no output schema and no parameter descriptions, the description is remarkably complete. It covers pagination, sorting, every kind value's meaning, the readAt side-effect behavior, the correct acknowledgment pathway, and the relationship to infrastructure_status. There is no important gap for an agent to call this safely and 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?

The input schema provides no descriptions, and the description does not directly explain the limit or cursor parameters. However, the phrase 'cursor-paginated' and the stated return shape { messages[], nextCursor } give enough implicit guidance that an agent can infer pagination flow. It could be stronger with an explicit statement like 'pass nextCursor as cursor to get the next page.'

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 and resource ('List this tenant's system + operator messages') and immediately differentiates itself from the related tools ack_message and infrastructure_status. The message kinds and behavior are clearly enumerated, so there is no ambiguity about what this tool returns.

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 tells the agent when to use ack_message instead, and clarifies that infrastructure_status only inlines the newest 5 unacked messages, making this the full paginated surface. This gives clear selection guidance relative to 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?

The description adds value beyond annotations by detailing the return value ({marked: true}), error handling (404 for unknown thread), and the effect of 'archived' status (hides from default inbox, refetching behavior). 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 concise (three sentences plus a front-loaded purpose). Every sentence adds necessary information with no 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?

Given the two parameters, no output schema, and available sibling tools, the description provides complete context: input details, output, errors, and usage boundaries.

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 schema coverage is 50%, the description adds meaning by listing the valid status values and explaining the archival behavior. It also provides context for threadId ('e.g. from inbox() or campaign events'). This compensates for the missing schema descriptions.

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

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

The description clearly states the verb 'Set' and the resource 'a thread's READ-STATE' for inbox triage. It also explicitly distinguishes from sibling tools 'label_thread' and 'reply'.

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 explains when to use the tool (for read/unread/archived flags) and provides alternatives for other actions (label_thread for labels, reply for responses). However, it does not explicitly state when not to use it beyond those comparisons.

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 provide readOnlyHint=true. The description adds context on the data shape (fields), scope (tenant-wide), and exclusions (bounce = hard only, opens not tracked), without contradiction.

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 a clear list and alternative references. No superfluous information; 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?

Given no output schema, the description explains return fields, scope, and tracking exclusions. Sufficient for understanding tool behavior, though could hint at data types.

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?

No parameters exist (schema has zero properties, 100% coverage). Baseline of 4 for zero-parameter tools is appropriate; description adds no parameter info but clarifies return semantics.

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 specifies 'Account-wide outcome totals across ALL campaigns' with a clear list of fields, and explicitly distinguishes from sibling tools (campaign_results, list_campaigns, account).

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 on when to use this tool vs alternatives: 'Use campaign_results for one campaign, list_campaigns per-campaign, or account for billing/quota.'

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 provide destructiveHint: true, and the description adds context about the status change, unaffected sent mail, no resume capability, and a 404 error. This goes beyond what annotations alone 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 concise with three sentences, no redundancy, and front-loaded important information. Slightly more structured formatting could improve readability, but it remains efficient.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, effect, irreversibility, error handling (404), alternative tool, and output format, making it fully informative.

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

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

The schema already describes campaignId as 'The campaign id returned by launch_campaign.' The description mentions 'Input: campaignId' but does not add significant new semantics beyond the schema's 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 tool pauses one campaign, changes status to 'paused', and stops tick scheduling. It distinguishes itself from the sibling tool 'pause_all' by specifying it affects a single campaign.

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 mentions when to use this tool (for a single campaign), provides an alternative ('Use pause_all to pause every active campaign at once'), and notes that there is no resume tool, giving clear context for decision-making.

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 destructive intent, and description adds specific behavioral details (status change, stops sends, return value). No mention of reversibility or prerequisites, but sufficient for the simple operation.

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

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

Extremely concise with two sentences plus a note. Front-loaded with purpose and effect.

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?

All necessary context provided: purpose, effect, return value, no inputs, and relationship to sibling tool. No 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?

No parameters, schema fully covers it. Description explicitly states 'No inputs', adding confirmation beyond 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?

Clearly states it pauses every active campaign for the tenant, with specific effect on status and scheduling. Distinguishes from sibling tool 'pause' for single campaign.

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

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

Explicitly instructs to use 'pause' for single campaign, providing clear when-to-use 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?

Although destructiveHint is already set, the description goes far beyond it: release is irreversible-this-cycle, no mid-cycle credit is granted, failed releases remain live and billed, deduplicated=true means no new work was performed, and idempotency key reuse can replay outcomes even after the 30-day window. This level of behavioral detail is exactly what an agent needs to safely call a destructive tool.

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

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

The description is front-loaded with the core action and is dense with uniquely useful content. However, the idempotencyKey and retry sections are somewhat repetitive—'same key... can only ever finish that set' is restated multiple times—so a more structured layout could improve comprehension without adding information. Overall, length is justified by the destructive, irreversible nature, but tightening would be better.

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 no output schema, the description fully documents expected return fields: releasedCount, failedCount, unreleased, billing, and deduplicated, including what each means. It also covers error handling (409), billing timing, minimum quantity, and the relationship to idempotency in a way that allows an agent to call the tool and interpret the response correctly in one flow.

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 only describes idempotencyKey (33% coverage); count and acknowledged are bare fields. The description compensates fully: count is relative ('releases that many MORE mailboxes, it does not set fleet to that size'), acknowledged must be true and represents quoted irreversible consent, and idempotencyKey semantics are explained in depth including retries, reused keys, and changed counts. It meaningfully adds what the schema lacks.

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 'Downgrade: release your N NEWEST live mailboxes now and lower the billed quantity', which names a specific verb, resource, and intended effect. It clearly distinguishes this destructive downgrade operation from add-oriented siblings by pointing to setup_infrastructure and configure_byo_domain for adding mailboxes.

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 is explicit about when to use the tool ('To ADD mailboxes use setup_infrastructure / configure_byo_domain') and gives detailed retry guidance: resend identical requests until failedCount is 0, use a NEW key for a genuine second downgrade, and wait/re-read infrastructure_status on a 409. The conditions and alternatives are unambiguous.

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 only destructiveHint=true as an annotation, the description carries the disclosure burden and fully delivers: daily-cap accounting, explicit refusal semantics with three reasons, retryable vs non-retryable handling, idempotent collapse behavior, and the subtle deduplication edge case. No contradiction with the annotation — 'destructive' fits a tool that produces real sending volume.

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?

Every sentence adds distinct, decision-relevant information — refusal reasons, retry cadence, dedup semantics, 404 case — so nothing is filler. The structural issue is that all of this is one dense paragraph; having the refusal and deduplication sections as separate bullets would make it easier for an agent 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?

This is a tricky send-side tool with no output schema, yet the description covers the normal return value, the refusal error object shape, retryability advice, idempotency rules, a subtle provider dedup edge case, and the 404 condition. An agent has everything it needs to decide, invoke, and interpret the result even without structured output definitions.

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

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

The description adds real nuance beyond the schema: for idempotencyKey it explains the body-hash fallback, the 10-minute local matching window, and the longer provider-side window that can cause a stale deduplicated:false. For body it adds that a stable body hash can be used as an idempotency key and that identical bodies can be collapsed by the sending provider. The basic content meaning of body is left implicit and schema coverage is 67%, so the value-added is high but not 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 first phrase says exactly what it does: 'Send a reply on an existing thread, from the mailbox that sent it.' This is a specific verb plus resource, plus the scope qualifier 'from the mailbox that sent it', which distinguishes it from broader send/campaign tools. The description also names the return shape ({ messageId, deduplicated }) in the same breath.

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

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

There is strong operational guidance (when a send will be refused, when retrying is useless, don't loop replies to manufacture volume), but no explicit statement of when to choose this tool versus a sibling like launch_campaign. Use-cases are implied via 'on an existing thread' but alternatives are never named.

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

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

With only a destructiveHint:false annotation, the description carries the full behavioral burden and fully delivers: it discloses that idempotencyKey controls response replay only and has no bearing on purchases, that jobId is a correlation id with no store or endpoint, that a result carrying provisioning is deliberately NOT recorded against the key, and that there is NO background retry. It candidly explains the refusal paths (registrar_optin_missing, registrar_unarmed, incomplete_registrant) and that billing reflects what actually landed. The description's credit for creating rather than destroying state is consistent with the destructive=false annotation — no contradiction.

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 front-loading is correct — the purpose is stated before details — and nearly every sentence carries semantic value. However, the prose is enormous (~700 words) with dense semicolon and parenthetical chains, and a few behaviors (no background retry, retry-to-converge) surface in more than one place, which hurts scannability relative to the 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?

For a high complexity tool with no output schema, the description almost fully ties out the contract: it defines billing projection fields, the provisioning field presence/absence state machine, jobId's non-usability, error codes, and the pointer to infrastructure_status's nextSteps. The only real gap is that the discriminated status/steps shape is referenced but not enumerated, and primaryDomain's role in the domain acquisition stays ambiguous.

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

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

Schema coverage is only 8% (one param has a description), so the description must compensate — and it largely does: the slot semantics for domains with ordinals 0..N-1, the inboxesEach vs distribution alternative with an example array, determinism of mailbox addresses with persona, and registerDomains/registrant/quoteOnly consent flows. The remaining gap is primaryDomain, which is name-dropped in the inputs list but never distinguished from the lookalike domains being purchased; the schema entry is just a string field, so the agent gains no clarity there.

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 and resource — 'Provision sending infrastructure: buy branded lookalike domains, create mailboxes, start warmup' — which immediately distinguishes it from read-only siblings like infrastructure_status and from teardown tools like remove_mailboxes. An agent can tell what this tool does and what it is not without reading any other schema.

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

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

The description routes the agent to the right action for each state: poll infrastructure_status for dailyCap, call contact_operator instead of waiting when capacity is held, re-call setup_infrastructure to converge DNS after 'pending', and pass quoteOnly:true first to preview billing before committing. Sibling tools and alternative behaviors are named explicitly with the exact conditions that select them.

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 goes beyond the `destructiveHint` annotation by detailing side effects: cancels pending sends, marks rows suppressed, last-write-wins relabeling, and the fact that notes are accepted but not persisted. This provides complete transparency beyond what annotations offer.

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 but packs in all critical details. The structure is front-loaded with the core purpose, then details. Minor improvement: could break into bullet-style for even quicker scanning, but overall 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?

Despite no output schema, the description fully covers input semantics, side effects, behavioral traits (last-write-wins), and caveats (no un-suppress). It leaves no ambiguity about what the tool does or its consequences for a 3-parameter tool.

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

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

Schema coverage is 0%, but the description fully compensates: it explains that `reason` is fixed to 'manual' (const), `note` is accepted but not persisted, and `email` is required. This adds significant meaning beyond the bare 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 specifies a clear verb ('suppress') and resource ('email address tenant-wide'), and distinguishes its purpose as the manual opt-out path for cases the typed-unsubscribe matcher misses. It names the exact inputs and effects, making the tool's role 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 explicitly states when to use ('manual opt-out path') and implicitly when not to use (bounce/complaint/unsubscribe are handled automatically elsewhere). It also warns there is no un-suppress tool and explains the last-write-wins behavior, guiding appropriate use.

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 set readOnlyHint=true. Description adds specifics: return shape with nullable mailboxEmail, oldest-first order, and error behavior. No contradictions.

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 paragraph covering purpose, input, output, error, and sibling hints. No redundancy; efficient but could be slightly more structured.

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 one parameter, no output schema, and high schema coverage, the description provides complete context: purpose, input, output shape, error, and usage alternatives.

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 with clear description for threadId. Description mentions it but adds no new semantic detail beyond the schema.

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

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

Explicitly states 'Full message history for ONE thread' with specific verb and resource. Distinguishes from siblings by naming inbox, reply, and label_thread.

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 when-to-use: 'Use inbox to LIST threads; reply to respond; mark/label_thread to triage.' Also notes 404 error for unknown threads.

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

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

The description discloses key behavioral traits beyond annotations: it states it's a partial patch (only passed fields changed), requires at least one of interestStatus/notes/tags, and mentions server-enforced enum validation. Annotations only provide destructiveHint=false, so the description adds useful context. However, it does not mention authorization needs or rate limits, which are minor gaps.

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

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

The description is well-structured with a clear lead sentence followed by a parameter list. It is relatively long but each sentence adds value. Minor redundancy: 'Inputs: ' could be integrated. Overall, it's concise for the amount of detail provided.

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 4 parameters, no output schema, and low schema coverage, the description thoroughly covers inputs, behavior (partial patch), and relationships to sibling tools (suppress_lead, list_leads). It also notes the contact-level scope and cross-campaign visibility. No missing aspects 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 0%, so the description fully carries the burden. It explains each parameter's role: email as key, interestStatus with explicit enum values and the note that it's server-enforced, notes and tags with constraints (maxLength, maxItems). It also clarifies that at least one optional param is required, adding 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 the tool's purpose: recording contact-level disposition keyed by email. It uses specific verbs ('record what you learned') and resource ('contact-level disposition'), and distinguishes itself from sibling tool 'suppress_lead' by explicitly noting that 'do not contact' is not a valid interestStatus.

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 when to use this tool versus alternatives: it notes that 'do not contact' should be handled via suppress_lead. It also mentions that the tool is filterable via list_leads, offering context for integration. No when-not-to-use scenarios are omitted.

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