domani

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

With no annotations, the description carries the full burden and does well: it reveals the internal process (RDAP sourcing, anonymous outreach, negotiation), pricing model (commission-only), and a key limitation (GDPR-redacted WHOIS makes many owners unreachable). It also states the required scope 'deals:write.' While it doesn't describe every edge case (e.g., non-response handling), it gives substantial behavioral insight beyond the tool name.

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

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

The description is three sentences, front-loaded with the main purpose and then expanding into process and caveats. Every clause adds value—no fluff or repetition. It is concise yet information-dense, making efficient use of the format.

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 only 2 parameters and no output schema, the description is quite complete: it covers the action, process, risks, cost structure, and auth requirement. It does not explicitly mention the response format or next steps after negotiation, but the described workflow (accept/counter) implies a result. This is solid 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?

The input schema already provides 100% coverage with descriptions for both 'domain' and 'max_budget.' The description adds no additional parameter-specific details, but the process context (e.g., negotiation, budget ceiling) is implicitly relevant. Since schema coverage is complete, a baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb-resource-action: 'acquire a specific taken, unlisted domain on your behalf.' It distinguishes from siblings like buy_domain and buy_aftermarket by specifying the domain is taken and unlisted, implying a broker service is needed. The title 'Acquire Domain (Broker)' reinforces the unique purpose.

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: for taking a 'specific taken, unlisted domain' rather than an available or listed one. It also notes caveats like 'many owners are unreachable' and 'commission-only, no upfront fee,' which help users decide if this approach is appropriate. However, it does not explicitly name alternative tools for other scenarios, so it stops short of full alternative guidance.

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

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

No annotations are provided, so the description must disclose side effects. It states 'publish at the registry' but does not mention that this is a mutation, potential propagation delay, irreversibility, or required permissions. Similar to the update_drive example, this is a significant gap for a write operation without annotation coverage.

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

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

Two sentences, front-loaded with the action, no redundant words, purposeful second sentence.

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 7 parameters and no output schema or annotations. The description provides the core purpose and prerequisite but does not cover expected response, error cases, or side effects. It's minimally acceptable but leaves 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 covers 100% of parameters with descriptions. The description adds value by explaining the source of the DS values ('from your zone provider after signing the zone'), which clarifies parameter origin 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?

Description uses specific verb 'publish' and resource 'DNSSEC delegation-signer (DS) record', clearly stating the outcome (enable DNSSEC). It distinguishes from siblings like get_dnssec and delete_dnssec by focusing on the add action.

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?

Description provides context: 'after signing the zone' and instructs to get DS values from provider. This implies the use case, though it does not explicitly exclude alternatives or mention when not to use. It's clear but lacks explicit alternatives.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: alias delivery, no mailbox slot consumption, same-domain requirement, and the API endpoint. However, it does not state side effects, reversibility, required permissions, or error behavior, leaving some transparency 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?

Three sentences, front-loaded with the primary action, followed by a practical use case and a constraint. Every sentence adds value 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 additive tool with no output schema, the description provides purpose, use case, constraints, and API route. It lacks explicit return/error information, but the operation is straightforward and the existing mailbox prerequisite is implied. This is reasonably 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?

Input schema covers all three parameters with clear descriptions and examples (100% coverage). The description's mention of alias formats and domain adds little beyond what the schema already provides, so the score stays at the baseline for high schema coverage.

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

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

The description clearly states the action ('Add an alias address'), the resource ('mailbox'), and the key distinguishing behavior ('delivers into an existing mailbox, without using a mailbox slot'). It also specifies a domain constraint, effectively differentiating it from create_mailbox and similar 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 provides a concrete use case ('multiple public addresses... landing in one inbox') and a critical prerequisite ('must be on the same domain as the mailbox'). While it does not explicitly name alternatives, the 'without using a mailbox slot' phrasing and sibling tools like create_mailbox make the intended usage evident.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses key behaviors: actions performed on match, forward/label argument requirements, the webhook_only special case, and priority ordering with first-match-wins. It omits permission requirements and return values but still offers substantial behavioral insight.

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

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

The description is three sentences long, front-loaded with the tool's purpose, and each sentence adds critical information: action types, match criteria, priority behavior, and API endpoint. There is zero filler and every word earns its place.

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

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

For a 9-parameter creation tool with no annotations and no output schema, the description covers match fields, all actions, priority ordering, and the API endpoint. It does not mention the enabled flag's default behavior or error/duplicate-rule handling, but the provided context is sufficient for an agent to construct a correct request. A 5 would require explicit coverage of these minor gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explicitly linking action_arg to forward and label actions, clarifying that webhook_only skips forward-to, and explaining the priority field's lower-first ordering. This enriches the parameter understanding without duplicating schema text.

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

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

The description clearly specifies the verb 'Add' and the resource 'inbound filtering rule to a mailbox.' It distinguishes itself from siblings like list_mail_rules and remove_mail_rule by describing the exact creation action and enumerating the actions and match fields supported.

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 strong usage context by explaining rule execution semantics (priority order, first match wins) and the action_arg dependency for forward and label actions. However, it does not explicitly state when not to use the tool or mention alternative tools like send_email or set_email_forward, so exclusions are only implied.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explains the core effect (future sends skip the address) and contrasts with automatic additions, but it does not mention idempotency, behavior when the address already exists, or required permissions. These gaps are noteworthy given the absence of 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 three concise sentences, front-loaded with the primary action, and each sentence adds value: purpose, usage context, and API endpoint. There is no wasted wording.

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

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

Given the low complexity (2 params, no nested objects, no output schema), the description is fairly complete. It explains the tool's purpose, the automatic-vs-manual distinction, and the HTTP method. It falls short only in not addressing potential edge cases like handling of duplicate suppressions, but this is minor for such a simple 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?

The schema already provides 100% coverage for both parameters ('address' and 'reason' with enum and default). The description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate—schema does the heavy lifting.

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

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

The description clearly states the tool's function: 'Manually add an address to your suppression list so future sends skip it.' It uses a specific verb and resource, and distinguishes this from the existing sibling tools like remove_suppression and list_suppressions by focusing on manual addition.

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

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

The description provides clear context on when to use the tool ('use this for addresses you want to stop emailing') and notes that hard bounces and complaints are handled automatically, implying the tool is for manual cases. It does not explicitly name alternative tools or exclusions, but the guidance is sufficient for a simple add operation.

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

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

With no annotations, the description discloses that the tool returns active listings with prices, implying a read-only operation. It does not describe pagination, how sort/order/max_price affect results, or authentication requirements. This is acceptable for a simple browse tool but leaves gaps beyond the basics.

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 action and return value, and ends with a useful pointer to buy_domain. Every sentence earns its place with no redundant or vague wording.

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 low-complexity tool with no required parameters and no output schema, the description adequately communicates the primary output (all active listings with prices). It does not need to detail return format or error handling, though mentioning that results respect the provided filters would have been slightly more complete.

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

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

Schema description coverage is 100% for all three parameters (sort, order, max_price) with clear descriptions. The tool description adds no additional parameter-specific meaning, so the baseline score of 3 applies.

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

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

The description states a clear purpose: 'Browse domains for sale on the Domani marketplace.' It specifies the scope ('Returns all active listings with prices') and distinguishes from the purchase action by referencing buy_domain, making it distinct from sibling 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 provides clear context for when to use this tool (browsing marketplace listings) and explicitly directs users to buy_domain for purchasing, establishing an alternative. However, it does not mention other alternatives like search or list_domains, nor does it 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?

With no annotations, the description carries the full burden and does well: it discloses the buy-now price cap via max_price, the USDC payment flow ('402 -> pay -> retry with payment_tx'), and the requirement to confirm price with the user. It doesn't fully detail error responses beyond 402, but the payment flow context is valuable.

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 (four sentences) and front-loaded with the core purpose. Every sentence contributes: purpose, when to use, user confirmation, max_price, alternative tool, and crypto payment flow. No 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?

Given the lack of output schema and annotations, the description covers essential operational context: the buyable precondition, the cap mechanism, the alternative for non-buyable listings, and the payment flow. It omits specifics like success response or fees, but for the complexity of a buy action, it 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 coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining max_price as a hard cap, referencing the USDC flow with payment_tx/payment_chain, and noting payment_method options. This enriches understanding of how parameters interact.

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: buying a taken domain listed on aftermarket at its buy-now price, natively. It distinguishes itself from siblings by specifying Afternic/Sedo, buy-now pricing, and the native (no external site) aspect, and contrasts with acquire_domain for make-offer listings.

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

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

Provides explicit when-to-use: 'Use when search shows a domain with for_sale.buyable = true' and when-not-to-use: 'If the listing is make-offer only (not buyable), use acquire_domain (broker) to negotiate instead.' Also includes a user confirmation step, giving clear operational 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?

With no annotations provided, the description carries the full burden. It discloses key behaviors: the 402 response with wallet address/amount, the two-step USDC flow, and the instruction to not explain protocol details. It does not mention success responses or error cases beyond PRICE_ABOVE_MAX, but the most unusual and important behaviors are well covered.

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 dense paragraph but every sentence contributes operational value. It front-loads the core purpose and then logically covers confirmation, bulk limits, and the USDC flow. While it is a bit long, it avoids fluff and is well organized for the complexity involved.

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 7 parameters, no output schema, and a complex payment flow, the description covers the critical contextual aspects: when to confirm, bulk constraints, USDC handling, and the 402 case. It does not describe post-purchase outcomes, but that is not essential for tool selection and invocation. The guidance is sufficient for an agent to execute the operation 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 schema already describes all 7 parameters with 100% coverage, so the baseline is 3. The description adds meaningful guidance beyond the schema, such as 'card only for bulk', the USDC payment flow linking payment_method, payment_tx, and payment_chain, and how max_price should be set from the user-approved price. This goes beyond mere schema repetition.

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 'Purchase one or more domains', a specific verb+resource statement. It clearly distinguishes itself from siblings by clarifying it handles purchases (not aftermarket or transfers) and supports bulk up to 10. The purpose is unambiguous and immediately knowable.

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 usage instructions: always confirm with the user, use card for bulk, and a detailed USDC flow with retry steps. It does not explicitly contrast with sibling tools like acquire_domain, but it covers the main decision points for when to use this tool and how to handle alternate payment methods.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals a key constraint (only 'watching' state backorders can be cancelled) and the effect (stops watching a domain), but it doesn't describe error behavior for invalid states, reversibility, or any side effects beyond stopping the watch.

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

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

The description is two short, front-loaded sentences with no filler. The core action and the state constraint are presented clearly and efficiently, earning every word its place.

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

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

For a simple one-parameter cancel operation, the description covers the essential purpose and constraint, making it reasonably complete. It omits error handling and postcondition details, but given the simple scope and lack of an output schema, it provides enough context 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?

The schema already documents the only parameter ('id') fully, and the description adds no further semantic detail. Since schema coverage is 100%, the baseline of 3 is appropriate, as the description doesn't need to compensate for missing parameter information.

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

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

The description clearly states the action ('cancelling a backorder') and the purpose ('Stop watching a domain'), using a specific verb and resource. It also differentiates from sibling cancel tools like cancel_broker_request and cancel_plan by focusing on backorders and the 'watching' state.

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 on when to use this tool: when you want to stop watching a domain via a backorder, and it explicitly notes that only backorders in the 'watching' state are eligible. It doesn't name alternative tools, but the precondition provides actionable usage guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses the mutation (cancellation) and the required scope (deals:write), but does not mention reversibility, side effects on related negotiations, or error behavior if the request is not active. This is adequate but not rich.

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

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

Two sentences, front-loaded with the action, no fluff. The scope requirement is the only extra context and earns its place.

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

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

For a simple one-parameter mutation tool with no output schema and no annotations, the description is adequately complete. It states the action, the prerequisite scope, and the parameter is fully documented in the schema. Minor gaps like error conditions are not critical given the simplicity.

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

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

Schema description coverage is 100% (request_id is described as 'The broker request ID'). The description adds no additional parameter semantics, but with full coverage the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Cancel an active domain acquisition request.' This clearly identifies the tool's function and distinguishes it from sibling tools like cancel_backorder, which targets a different resource.

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 on when to use the tool (against an active domain acquisition request) and notes the required deals:write scope. It doesn't explicitly name alternatives or exclusions, but the specificity of 'active' and the scope requirement provide sufficient 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?

With no annotations, the description carries the full burden. It discloses that the subscription remains active until the end of the billing period and then reverts to free, plus notes the return value (cancellation date). This is meaningful behavioral context, though it does not cover reversibility or confirmation requirements.

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

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

The description is two sentences, front-loaded with the core action and then adding relevant behavioral details. There is no fluff or redundant information.

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

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

For a simple zero-parameter tool with no output schema, the description fully covers what happens (billing-period grace, revert to free) and what is returned (cancellation date). It is complete enough 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?

The tool has zero parameters and the schema is empty, so there is nothing to document. Per the baseline for 0-parameter tools, a score of 4 is appropriate; the description adds no parameter info because none exists.

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

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

The description states a specific action (cancel) on a specific resource (Pro subscription), immediately clarifying the tool's function. It also distinguishes from sibling tools like 'upgrade_plan' and 'cancel_backorder' by mentioning the subscription context.

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

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

The description implies this is the tool for canceling the user's Pro subscription and explains the post-cancellation behavior, but it does not explicitly state when to use it over alternatives or provide any exclusions. Since it is the only cancel-plan tool, the usage context is fairly clear, but no explicit guidance is given.

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

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

No annotations are present, so the description carries the behavioral burden. It clearly discloses the specific checks performed (MX, SPF, DMARC, DKIM) and the auto-detection of the email provider, which is valuable beyond the tool name. It does not, however, describe return format, error conditions, or network behavior, but for a read-only check the core behavior is well covered.

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

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

Two short sentences, front-loaded with the action and specific records. No redundant or filler content; every clause adds 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?

Despite lacking an output schema and annotations, the tool is simple (one parameter, no nested objects). The description adequately covers what the tool does and the auto-detection behavior. It doesn't explain the return format, which would be useful, but the description is sufficiently complete for selection and 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?

The schema already documents the single 'domain' parameter with 100% coverage. The description restates 'for a domain' without adding format, validation, or examples beyond the schema. Baseline of 3 applies.

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

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

Description states a clear purpose with specific verb and resource: checking email DNS health, listing MX, SPF, DMARC, DKIM. This distinguishes it from siblings like dns_check (generic DNS) and check_email_deliverability (deliverability focused).

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

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

No explicit guidance about when to prefer this tool over check_email_deliverability or dns_check. Usage is only implied by the purpose statement; no alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden. It discloses key behavioral traits: it runs the same checks as send_email, does not send an email, and does not consume quota. This reassures the agent that it is a non-mutating preflight, though it does not explicitly state all side-effect-free behavior or auth requirements.

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

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

Three sentences: first states the core function, second gives usage context, third provides the endpoint. No fluff or redundancy, and key information 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?

The description provides good usage context but does not explain what the check returns or how to interpret the result, especially since there is no output schema. Additionally, the API endpoint's address concept is not reconciled with the domain/slug parameters, leaving a minor gap for an agent trying to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; the API path uses an '{address}' placeholder while the schema requires separate 'domain' and 'slug' fields, which could cause slight confusion but does not break understanding since the schema descriptions are clear.

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: running the same deliverability and abuse-safety checks as send_email, but without sending or consuming quota. This specific verb+resource+scope distinguishes it from the sibling send_email tool and other email-related tools.

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

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

It gives explicit guidance on when to use: 'before authentication, payment, onboarding, or high-volume messages.' It also implies when not to use (when you want to actually send) by noting it does not send. However, it does not explicitly name alternative tools or provide exclusion scenarios.

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

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

With no annotations, the description carries the burden. It discloses that the operation is a pre-check, returns price and eligibility status, and lists possible blockers. It implicitly suggests no side effects, but does not explicitly state safety or permissions.

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

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

Two sentences, front-loaded with the main purpose, followed by return values and usage. Every sentence earns its place with no filler.

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

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

Given the tool's simplicity (1 param, no output schema), the description covers what it does, when to use, and what it returns. It could be slightly richer on the exact shape of the response or error cases, but it is adequate.

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% for the single domain parameter, and the schema already provides an example ('mysite.com'). The description adds 'domain' in context but does not add new syntactic or format details 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 uses specific verb 'Pre-check' plus the resource 'whether a domain can be transferred', clearly distinguishing it from transfer_domain and check_transfer_status. It also lists what it returns, reinforcing the tool's role.

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 'Always call this before transfer_domain', which is a strong usage directive. It does not mention exclusions or alternatives like check_transfer_status, but the timing relative to transfer_domain is clear.

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

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

With no annotations, the description carries the burden of disclosure. It specifies the output: detailed status with a set of enumerated values and actionable hints. It does not mention potential side effects (likely none) or errors, but for a read-only status check this is sufficient.

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 action, and includes the key return values. No wasted words, and the structure is effective for quick parsing.

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 the essential information: what it does, what it returns, and the specific valid statuses. It lacks detail on 'actionable hints' but this is a minor 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?

Schema coverage is 100% since the only parameter 'domain' is described in the schema. The description does not add additional semantics about the parameter format or constraints, so it relies on the schema. Baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Check the status') on a specific resource ('an inbound domain transfer'). It also lists the exact status values returned, distinguishing it from sibling tools like check_transfer_eligibility and watch_transfer.

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

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

The description clearly implies when to use this tool: when you need the current status of an inbound domain transfer. It does not provide explicit exclusions or alternatives, but the context is clear enough for an agent to select it appropriately.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the identity is free, instant, and results in a live profile page, and mentions the future upgrade path. However, it doesn't address details like slug uniqueness, whether identities can be reclaimed, or 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 three sentences with no filler. The first sentence front-loads the core action and value, while the last sentence succinctly lists optional fields. Every part earns its place.

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

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

For a simple claim tool with no output schema, the description provides adequate context: the subdomain format, the live profile page nature, and the upgrade path. It doesn't describe return values or error handling, but the schema and simplicity of the operation make 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 input schema has 100% parameter coverage with descriptions for all six fields, so the baseline is 3. The description summarizes the optional fields ('Optional name/bio/emoji/email/links') but doesn't add meaning beyond the schema, which already explains each parameter.

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

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

The description clearly states the action ('Give your agent a free identity') with a specific resource ('at <handle>.domani.run') and conveys the key differentiator ('no domain purchase, instantly'). This distinguishes it from sibling domain-acquisition tools like acquire_domain and buy_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?

The phrase 'The frictionless way to start; upgrade to your own real domain later' provides clear context for when to use this tool—as an initial step before committing to a custom domain. It implicitly contrasts with purchasing/acquiring domains but doesn't explicitly name alternative tools.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral effect: email to unmatched addresses will be dropped again, and specifies the DELETE API endpoint. This goes beyond a simple 'remove' statement. However, it does not mention error behavior or idempotency, but for a straightforward removal tool, this is adequate.

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

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

The description is two sentences long, front-loaded with the primary action, and includes only essential details: the action, the consequence, and the API endpoint. No 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 single-parameter delete operation with no output schema, the description is complete. It explains what happens (removal) and the effect (dropped emails), plus the API endpoint. It doesn't discuss reversibility, but that is covered by the existence of the counterpart 'set_catch_all'. The complexity is low, and the description suffices.

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

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

Schema description coverage is 100% for the single 'domain' parameter, with the schema already describing it as 'Domain to clear the catch-all on'. The description mentions the API path containing the domain, but adds no further semantic detail. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description begins with 'Remove the catch-all on a domain', which is a specific verb and resource. It clearly distinguishes from the sibling tool 'set_catch_all' by indicating removal rather than creation. The API endpoint further reinforces the exact 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 clearly indicates when to use the tool: when you want to remove the catch-all. The consequence ('Email to unmatched addresses will be dropped again') implies the context. It does not explicitly name the alternative 'set_catch_all', but the inverse relationship is evident from the sibling tools, providing adequate guidance.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It explicitly discloses the default merge behavior, collision policy (source wins), and the replace=true mode for an exact mirror. It does not cover potential side effects like propagation or reversibility, but the core behavioral nuances are well addressed.

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

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

The description is two sentences long, front-loaded with the core purpose, and efficiently packs in the default behavior and the replace flag. Every word earns its place.

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

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

For a moderate-complexity tool with no output schema and no annotations, the description provides sufficient context: it explains the action, the default and alternative behaviors, and gives an example. It does not explain return values, but this is not required without an output schema.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a useful example of record types (A/CNAME/MX) and reiterates the merge/replace semantics, but these are already captured in the schema. No significant new parameter-related meaning is provided beyond what the schema offers.

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 ('Copy'), identifies the resource ('DNS setup of one domain you own'), and provides a concrete example (brand.com → brand.dev). It clearly distinguishes itself from sibling DNS tools like set_dns or snapshot_dns.

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

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

The description clearly conveys the context for use (copying DNS between two owned domains) and defines the default merge behavior. It does not explicitly exclude alternatives or name sibling tools, but the use case is 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 no annotations provided, the description carries the full burden and excels: it discloses automatic DNS setup for platform domains, manual instruction generation for imported domains, the specific MX_REPLACEMENT_REQUIRES_CONFIRMATION failure mode, and the presence of a next_steps array. This is far beyond what annotations would typically provide.

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 primary purpose and every sentence earns its place. It covers auto-detection, two status paths, the MX conflict resolution, next_steps, and provider lists without any fluff. The structure is logical and compact.

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 and no annotations, the description is highly complete: it explains the main behavior, domain provenance variants, a tricky edge case, and hints at the output shape (next_steps). It doesn't fully elaborate on the method parameter or the complete response object, but these are minor gaps for an otherwise thorough description.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context: it links target to auto-detection, explains dry_run as a preview, and relates confirm_replace_mx to replacing MX records. It also enumerates valid provider values, giving the provider parameter richer semantics than the schema alone.

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 statement: 'Connect a domain to a hosting or email provider.' It further distinguishes itself from siblings by detailing auto-detection, platform vs imported domain handling, and listing supported providers (vercel, google-workspace, etc.), making its purpose unmistakable.

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

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

The description provides clear usage context: auto-detect provider from target or pass explicit provider, and it gives a concrete workflow for the MX replacement edge case (use dry_run, confirm with user, retry with confirm_replace_mx). It does not explicitly say when not to use this tool or name alternatives, but the guidance is sufficiently actionable.

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

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

With no annotations, the description fully carries the behavioral burden. It discloses critical behaviors: availability polling every few minutes, charging only on successful catch, the need for a card on file or 'payment_method: balance', and the best-effort nature with potential competition from drop-catchers. This is rich transparency beyond what any annotation could provide.

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 compact, well-organized paragraph. Every sentence adds new, essential information: purpose, polling behavior, payment condition, user confirmation, and risk. There is no redundancy or filler, making it highly 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 lacking an output schema, the description covers all necessary context for a 3-parameter action tool: target domain, payment prerequisites, cost model, and failure mode. It also implies how to check outcome (via list_backorders) without needing to state it. The description is complete 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?

Schema coverage is 100%, so the baseline is 3. The description adds meaningful nuance by clarifying that a card on file is required unless payment_method is set to 'balance', and by emphasizing the need to confirm the domain with the user. These details go beyond the schema descriptions, enriching parameter understanding.

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 with a specific verb and resource: 'Place a backorder on a domain that is currently registered to someone else.' It distinguishes itself from siblings like buy_domain by focusing on domains that are taken and will be watched for availability, making its scope obvious.

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 the tool: when the domain is already registered to someone else and you want to catch it on drop. It also instructs to 'Confirm the domain with the user first,' which is a practical usage guideline. However, it does not explicitly name alternative tools or state when-not-to-use, so it falls short of a 5.

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

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

With no annotations, the description carries the transparency burden. It discloses side effects ('Provisions the mailbox on our mail server, publishes DNS when we manage it') and states exactly what is returned (DNS records, mail client settings, one-time app password). It lacks mention of costs, failure conditions, or reversibility, but covers the core behavior well.

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 and packs in the core concept, the alternative, a key parameter condition, the provisioning behavior, and the return payload. No filler or redundancy; it's 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?

Despite lacking output schema and annotations, it explains what the tool returns, when to use it, and the prerequisite of owning the domain. It also includes the API route. It doesn't detail post-creation steps or edge cases, but for a creation tool with 4 params, this is solid.

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 covers all 4 parameters with descriptions, so the baseline is 3. The description adds value by explaining the workspace_id semantics ('atomically adopt the domain boundary') and giving a concrete slug example ('me' for me@mysite.com). It also implicitly maps domain/slug to the mailbox address.

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: 'Create a real IMAP/SMTP mailbox on a domain you own.' It explicitly contrasts with 'an API mailbox,' differentiating it from sibling create_mailbox. This makes the tool's 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 phrase 'instead of an API mailbox' gives an explicit alternative, and 'on a domain you own' establishes a prerequisite. The condition around workspace_id ('Pass workspace_id to create it in a workspace you own and atomically adopt the domain boundary') clarifies when to include it. However, it doesn't enumerate other sibling alternatives or state when not to use it in more detail.

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

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

With no annotations, the description carries full responsibility for disclosing side effects. It reveals atomic domain adoption, DNS auto-configuration, DNS records for imported domains, mailbox limits, and force override behavior. This is strong behavioral disclosure, though it omits return value format and potential error conditions.

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 longer than ideal but every sentence serves a purpose. It is front-loaded with the core action, then systematically covers domain scenarios, limits, and override. The structure is logical and achieves high information density without being overly verbose.

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

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

Given the tool's complexity (5 parameters, no output schema), the description covers many important edge cases: domain types, account limits, workspace ownership, and DNS handling. It does not describe the response payload, which would be helpful, and it misses explicit differentiation from create_hosted_mailbox, but overall it is quite complete.

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

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

Schema coverage is 100%, providing a baseline of 3. The description adds meaning beyond the schema by explaining domain type nuances (custom, imported, domani.run), ownership requirements for workspace_id, and the effect of force=true. This enriches the raw parameter 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 'Create an email address' with a specific verb and resource. It goes into detail about slug, domain, workspace, and force options, but does not explicitly distinguish from the sibling 'create_hosted_mailbox', which could be a similar or overlapping 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 provides contextual guidance for different scenarios: 'For custom domains', 'For imported domains', 'For domani.run', and explains when to use workspace_id and force. However, it does not explicitly mention alternatives or when NOT to use this tool, such as pointing to create_hosted_mailbox or other 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?

With no annotations, the description takes on the transparency burden. It discloses a crucial behavioral trait: 'The secret is returned once - store it,' which alerts the agent to capture the secret immediately. It also includes the API endpoint. However, it omits other details like permission requirements or limits, but the one-time secret is a key disclosure.

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 an API path. The first sentence states the primary action, the second provides a critical caveat, and the API reference is a compact technical detail. No wasted words; it is front-loaded and well-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?

For a simple create tool with no output schema, the description covers the essential context: what it does, the one-time secret behavior, and the API endpoint. It does not detail the response format, but the description of the secret being returned implies it. The sibling context and schema fill in the remaining gaps, making this sufficiently complete.

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

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

Schema description coverage is 100%, meaning all parameters are already described: slug ('Hosted mailbox slug'), label ('Label to identify this app password'), and domain ('Hosted mailbox domain'). The description adds no additional parameter-specific semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Create an app password for a hosted mailbox, used as the password in a mail client.' This specific verb+resource combination distinguishes it from siblings like create_mailbox (which likely creates a mailbox account) and list_mailbox_credentials (which lists credentials). The title 'Create App Password' further reinforces the purpose.

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 when to use this tool: when you need an app password for a mail client to access a hosted mailbox. It does not explicitly mention alternatives or when not to use, but the wording 'used as the password in a mail client' provides clear context. The sibling tool list also helps differentiate, but explicit exclusion is absent.

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

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

With no annotations, the description carries the full burden and excels. It discloses critical behavioral traits: the key is returned only once ('save it immediately'), scope attenuation limits what can be granted, and spend caps are enforced server-side. It also details the implications of each scope, including irreversible actions like email:delete and the redaction of auth secrets without email:auth_secrets.

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 due to the exhaustive scope enumeration, but it is well-structured as a scoped list with parenthetical endpoint details and warnings. Key behavioral notes are front-loaded, and the imperative final sentence adds actionable guidance. It earns its length by providing essential reference material for an AI agent, though it could be trimmed by referencing external docs for the full scope list.

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

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

Given the complexity of 7 optional parameters and no output schema, the description covers the critical aspects: key delivery, scope restrictions, spend caps, and dangerous permission warnings. It does not explicitly outline the response structure beyond the key, but the warning to save it immediately implies the response contains it. Overall, it is sufficiently complete for an agent to use the tool correctly, with minor gaps around exact response fields.

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 schema coverage is 100% (baseline 3), the description significantly enriches parameter understanding. It expands the scopes parameter with a comprehensive list of valid values and their endpoints, explains the semantics of spend caps, and adds imperative usage guidance for max_per_tx/max_per_month. This goes well beyond the schema's brief 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 opens with 'Create a new API token with optional scoped permissions and spend caps,' clearly stating the specific verb (create), resource (API token), and key features. It distinguishes itself from sibling tools like list_tokens and revoke_token by focusing on creation and its associated options.

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 strong contextual guidance, such as 'When minting a token for a sub-agent that can buy, ALWAYS set max_per_tx/max_per_month.' It also explains scope attenuation and warns about dangerous scopes like email:delete. However, it does not explicitly name alternatives or state when-not-to-use, so it falls short of a 5.

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

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

With no annotations, the description takes on the transparency burden. It meaningfully discloses that the secret is returned only once and that HMAC-SHA256 is used for verification, but omits potential behaviors like duplicate URL handling or idempotency.

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

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

Three sentences, front-loaded with the purpose, and every sentence contributes essential information (constraint, event selection, secret handling). No filler 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 two-parameter tool with no output schema, the description adequately covers the key return value (secret) and usage constraints. However, it omits the webhook ID needed for subsequent updates/deletes, and does not address duplicate URL behavior.

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

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

Schema description coverage is 100%, and the description adds no additional meaning beyond what the schema already provides for url and events (e.g., HTTPS, example events). Baseline 3 is appropriate.

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

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

The description states a specific action ('Register a new webhook endpoint') and resource ('event notifications'), clearly distinguishing it from sibling tools like update_webhook or delete_webhook.

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

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

Provides clear context on when to use (setting up a webhook, selecting events, HTTPS requirement) but does not explicitly contrast with alternatives like update_webhook or list_webhooks, and gives no exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful context about registry-level operation and the consequence of removing all DS records, but does not disclose potential side effects like propagation delays, reversibility, or failure behavior.

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

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

Two sentences, front-loaded with the action, and zero wasted words. The description is efficient and directly to the point.

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

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

For a simple two-parameter tool with no output schema, the description provides sufficient information to understand the operation and an important side effect. It could mention what happens on success or error handling, but overall it is complete for this complexity level.

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 descriptions for both parameters ('Domain name' and 'Key tag of the DS record to remove'). The description does not add significant meaning beyond the schema, aside from reinforcing that the key tag identifies the DS record.

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

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

The description states a specific verb ('Remove'), a specific resource ('DNSSEC delegation-signer (DS) record'), and a specific method ('at the registry by its key tag'). It clearly distinguishes from sibling tools like add_dnssec and get_dnssec.

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

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

The description clearly implies when to use this tool (when you need to remove a specific DS record) and adds the context that removing all DS records disables DNSSEC. It does not explicitly name alternatives or exclusions, but the purpose is 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 no annotations, the description carries full burden. It discloses destructive scope (all messages and attachments), the confirm requirement, and the preview step. This goes beyond simple 'delete' and gives the agent essential safety information. The API endpoint is a useful technical detail.

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

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

Three concise sentences. The first states the destructive action, the second gives the safety requirement, and the third provides the API endpoint. Every sentence earns its place 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?

For a destructive tool with no annotations and no output schema, the description covers the key context: what gets deleted, the confirmation requirement, and the preview mechanism. It could mention irreversibility explicitly or note effects on aliases, but the provided information is sufficient for an agent to invoke the tool safely.

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

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

Schema coverage is 100%, so baseline is 3. The description adds critical meaning for the confirm parameter: 'Requires confirm=true. Call without confirm first to see what will be deleted.' This goes beyond the schema's 'Must be true to actually delete. Omit to preview.' by explaining the two-step usage pattern.

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 'Delete a mailbox and all its messages (including attachments)', which uses a specific verb and resource with scope. It distinguishes itself from sibling tools like delete_message and delete_messages by focusing on the entire mailbox.

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 instructs to call without confirm first to preview, then with confirm=true to delete. This provides clear operational guidance. Although it doesn't explicitly name alternative tools for deleting individual messages, the preview/confirm workflow and scope make usage clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the message is moved to Trash (not permanently deleted) and is reversible, which is critical context. It does not mention permissions or error scenarios, but the key reversibility trait is disclosed.

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 concise sentences plus the API endpoint, with no wasted words. The action is front-loaded, making it immediately clear what the tool does.

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-message deletion tool, the description provides purpose, reversibility, and endpoint. It does not mention the return format, but given the simplicity and the rich schema, it is nearly complete for an agent to use correctly.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds the API endpoint structure showing how parameters map to the URL path, but this is marginal beyond the schema's own 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 tool moves a single email message to Trash, with a specific verb and resource. It distinguishes from the sibling delete_messages by its singular scope ('an email message') and includes the API endpoint for added specificity.

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 notes that deletion is reversible via update_email_messages action=restore, providing an alternative for restoration. While it does not explicitly contrast with delete_messages, the singular phrasing implies single-message use, offering clear context without explicit when-not guidance.

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

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

With no annotations provided, the description carries the full burden and does so excellently: it discloses that messages are moved to Trash (not permanently deleted), that the operation is retry-safe via idempotency key, that a durable per-item receipt is returned, and that it is reversible via update_email_messages. This is substantial behavioral context beyond merely saying 'delete messages'.

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: four short sentences, each adding distinct value (purpose, retry behavior, reversibility, and explicit API endpoint). There is no filler or repetition of schema 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 moderate complexity (bulk operation, idempotency, no output schema), the description covers the key aspects: endpoint, retry semantics, reversibility, and return receipt. It does not describe partial-failure behavior or the exact structure of the receipt, but the provided information is sufficient for an agent to proceed with a reasonable degree of confidence.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context for the idempotency_key parameter by explaining when and how to reuse it ('after timeouts'), and it clarifies the nature of the result ('durable per-item receipt'). This adds value beyond the schema's field descriptions.

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

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

The description clearly states the action ('move messages to Trash') and the resource ('messages'), and distinguishes this bulk operation from the sibling delete_message via 'Retry-safely' and 'per-item receipt'. The endpoint 'POST /api/emails/{address}/messages/delete' further reinforces the specific resource and 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 clear retry guidance ('Reuse the exact idempotency key after timeouts') and explicitly names an alternative for reversing the operation ('update_email_messages action=restore'). However, it does not explicitly state when to choose this bulk tool over the singular delete_message or other message-related tools.

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

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

With no annotations provided, the description carries the burden of disclosing side effects. It explicitly states that 'All pending deliveries will be cancelled' and 'This action cannot be undone,' which are critical behavioral traits beyond a simple delete. This provides valuable context about irreversibility and impact on ongoing deliveries.

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, using only two sentences to convey the core action and key caveats. It is front-loaded with the main verb and includes only essential information without any filler.

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

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

For a simple delete operation with one parameter and no output schema, the description covers the essential aspects: what it does, the cancellation of pending deliveries, and irreversibility. It doesn't mention error handling or where to find the webhook_id, but these are not critical for this level of simplicity. Overall, it is sufficiently 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?

The input schema already provides complete coverage for the single parameter webhook_id, with a clear description. The description adds no additional meaning or format details beyond the schema, so it provides minimal added value. Baseline score of 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Delete a webhook endpoint.' This distinguishes it from sibling tools like create_webhook and update_webhook. The purpose is immediately clear.

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

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

The description implies usage when a webhook needs to be removed, but does not explicitly state when to use it over alternatives or mention any prerequisites. It does not name alternative tools like update_webhook or provide exclusion criteria. Thus, usage is only implied.

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

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

No annotations are provided, but the description discloses the operational mechanism (DNS-based), the two output categories (taken vs candidates), and a limitation (no pricing). It also notes the speed advantage over search. This is meaningful behavioral context beyond the tool's name and 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 four sentences, each providing distinct information: function, output, usage guidance, and a specific preset recommendation. No filler 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?

Given no output schema, the description adequately explains the return categories and clearly defines the workflow context (pre-search filter). It covers the main decision points an agent needs: what the tool does, when to use it, and how to leverage the extended preset. The absence of output schema is compensated by the explicit 'taken/candidates' summary.

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 descriptions for all three parameters. The description adds limited additional parameter meaning, mainly the strategic use of the 'extended' preset in certain scenarios, but the schema already documents the parameter values and defaults. Thus baseline 3.

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

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

States a specific verb ('tests/checks') and resource ('domain existence across many TLDs at once'). Clearly distinguishes from sibling 'search' by noting speed and lack of pricing, and explicitly positions it as a pre-filter before search. Also indicates output types.

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: 'Use this to narrow down before calling search for pricing.' Also recommends using the 'extended' preset when basic TLDs are taken. This tells the agent exactly when to invoke this tool and when to defer to search.

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

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

With no annotations provided, the description must carry the behavioral burden. It conveys a read-only intent via the verb 'check' and lists the data points, but it does not disclose whether it works for any domain or only domains under the account, nor does it describe the output format or any side effects (e.g., external queries). This leaves some ambiguity.

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

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

The description is a single, front-loaded sentence that efficiently lists the key checks. No wasted words; it 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?

The tool is simple with one parameter and no output schema. The description sufficiently captures the core scope (DNS, SSL, email, expiry) for an agent to select it appropriately. It does not explain the return structure, but that is not critical for a straightforward health check tool. Sibling context is available, though not directly referenced.

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

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

Schema description coverage is 100% for the single 'domain' parameter, with 'Domain to check status for' already explaining its meaning. The tool description adds no additional parameter detail beyond restating that it is a domain health check, so the baseline of 3 applies.

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

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

The description clearly states a specific verb-resource pair ('Check domain health') and enumerates distinct aspects (DNS propagation, SSL status, email MX configuration, expiry date). This differentiates it from sibling tools like dns_check or whois_lookup, which focus on individual checks.

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

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

The description implies usage as a domain health overview but does not explicitly state when to prefer it over alternatives like dns_check or whois_lookup. There are no exclusions or alternative tool mentions, so guidance is only implicit.

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

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

No annotations are provided, so the description carries full burden. It discloses the required domains:transfer scope, the BUDGET_EXCEEDED return and retry behavior, and that the operation creates an escrow deal and starts the transfer. It does not mention other failure modes or whether finalization is irreversible, but the key behavioral traits are covered.

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

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

Three sentences, front-loaded with the core action, followed by scope and an edge case. Each sentence adds value, with no filler 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?

Given the tool has no output schema and moderate complexity, the description covers the primary action, required scope, and a specific error/retry path. It does not describe the success response format or other potential errors, but the essential information for invocation is present.

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 useful context for confirm_over_budget (the BUDGET_EXCEEDED flow) and for payment_method by claiming the same methods as purchase (card, USDC, x402). However, the schema enum lists 'balance' instead of 'x402', creating a discrepancy. negotiation_id and payment_method still rely mostly on schema descriptions, and with 67% coverage, the description only partially compensates.

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: the buyer pays the agreed price to create an escrow deal and start the transfer. It uses specific verbs like 'pay', 'create', and 'start', and distinguishes this from sibling negotiation tools like make_offer and respond_to_offer by focusing on finalization.

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

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

It provides clear context on when to use the tool: as the buyer finalizing an agreed negotiation. It also explains the special over-budget flow for broker-sourced acquisitions and the retry with confirm_over_budget, but does not explicitly name alternative tools or exclusion cases beyond the budget scenario.

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

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

With no annotations, the description carries the full disclosure burden. It explains that the original message context is included, that a note can be prepended, and that the subject is auto-prefixed with 'Fwd:'. It does not cover permissions, rate limits, or failure behavior, but for a forwarding operation, these key behaviors are well disclosed.

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

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

Three short sentences, front-loaded with the core action, and each sentence adds value. The API endpoint is useful for technical integration, and there is no redundant text.

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 5 parameters, all documented, and no output schema. The description explains the forwarding behavior, the inclusion of original context, and the optional note, which is sufficient for an agent to correctly invoke the tool. It does not mention return values, but for a straightforward forward operation this is not a critical 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 input schema covers all parameter descriptions (100% coverage), so baseline is 3. The description adds meaningful context beyond the schema: it explains the 'text' parameter as an optional note to prepend, and the auto-prefix behavior clarifies why there is no subject parameter. This enriches 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 uses a specific verb ('Forward') with a clear resource ('an email message to another address'). It also distinguishes from siblings like send_email or reply_to_message by noting it includes original message context and auto-prefixes subject with 'Fwd:'.

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

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

The description clearly implies the tool is for forwarding emails, but it does not explicitly mention when to use this instead of alternatives like reply_to_message or send_email. The context is clear enough for an agent to infer, but there is no explicit when/when-not guidance.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly indicates a read operation ('Get') and lists return fields, but does not disclose authentication prerequisites, error cases, or rate limits. This is adequate for a simple getter, but not rich.

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

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

Two sentences with no extraneous information. The first enumerates return fields, and the second provides a relevant prerequisite context. Every word contributes to understanding the tool's purpose and use.

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 read-only tool, the description covers the key return fields and a relevant business rule. It doesn't describe response structure, but given the simplicity, the provided information is sufficient. The lack of an output schema is partially compensated by listing the fields.

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, so parameter semantics are trivially satisfied. The rubric sets a baseline of 4 for no-parameter tools, and the description correctly avoids inventing parameter 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 uses the specific verb 'Get' with the resource 'your account details' and enumerates the exact fields returned (payment status, has_contact, referral code). This clearly distinguishes it from sibling getter tools like get_domain_info or get_activation.

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 sentence 'Contact info must be set before purchasing domains' provides a concrete use case for checking contact status before a purchase. This gives clear contextual guidance, though it does not explicitly mention alternatives or when-not-to-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?

No annotations are provided, so the description must fully disclose behavioral traits. It does not state whether the operation is read-only, has side effects, or requires any permissions. The agent cannot determine if this call is safe or destructive without additional context.

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

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

The description is two sentences, each serving a distinct purpose: defining functionality and providing usage context. No unnecessary words, front-loaded 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?

For a simple tool with no parameters and no output schema, the description covers purpose and usage well. However, it could be improved by briefly mentioning the return value format or that it's a safe read 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?

There are no parameters, and schema coverage is 100%. According to the rubric, zero parameters earn a baseline of 4, and the description adds value by clarifying the tool's purpose 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 it retrieves 'product milestones and next useful actions for this account', providing a specific verb and resource. It distinguishes itself from siblings by its unique focus on activation status, though it does not explicitly differentiate from similar 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 says 'Use this after authentication instead of treating token setup as success', providing clear context and a specific alternative to avoid. This is excellent guidance for the agent.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It explicitly notes a side effect: 'Automatically unlocks the domain if it's locked,' which is important for a tool that might otherwise appear read-only. It does not mention return format or permissions, but the key behavior is disclosed.

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

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

The description is three sentences, each earning its place: what the tool does, a key side effect, and how to use the result. It is concise and front-loaded with the primary purpose.

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

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

For a tool with a single parameter and no output schema, the description covers the essential context: the purpose, the workflow (initiating a transfer), and a side effect. It could mention eligibility prerequisites, but the core is 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?

Schema coverage is 100%, with the 'domain' parameter already described as 'Domain to get auth code for.' The description adds no additional semantic detail about the parameter, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: obtaining the EPP/auth code needed to transfer a domain. It uses a specific verb ('Get') and resource ('EPP/auth code'), and distinguishes itself from sibling tools like check_transfer_eligibility and transfer_domain by focusing on the code retrieval step.

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 the tool: when transferring a domain to another registrar, and instructs to give the code to the new registrar. It does not explicitly mention alternative tools or exclusions, but the use case is well implied.

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

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

No annotations are present, so the description must convey behavioral traits. It discloses that the tool is a read-only 'poll' and includes a privacy guarantee ('Never exposes the buyer's identity or budget'), which is valuable beyond typical read operations. It doesn't detail error cases or idempotency, but these are less critical for a read tool.

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

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

Two sentences, front-loaded with the essential 'Owner-agent read path' label, and no redundant words. Every sentence adds value: the first states the action and return fields; the second sets privacy expectations.

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?

Although there is no output schema, the description explicitly lists the returned information (domain, offer, whose move, available actions) and what is deliberately withheld (identity, budget). For a single-parameter read tool with strong schema coverage, this is complete.

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

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

Schema coverage is 100% and the token parameter is well-described in the schema. The description's mention of 'your token' adds no new meaning beyond the schema's 'outreach token from your inquiry email.' Baseline of 3 is appropriate.

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

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

The description states a clear verb+resource+scope: 'poll the current, anonymized state of a broker inquiry.' It distinguishes itself from sibling write tools (e.g., respond_to_broker_inquiry) and listing tools (list_broker_requests) by explicitly labeling it as the 'Owner-agent read path.'

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

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

It provides the context of use ('before acting') and identifies the audience (owner-agent). It does not explicitly name alternative tools, but the phrase 'before acting' implies using this to gather state prior to operations, which is clear enough.

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

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

With no annotations, description carries full burden. It discloses role-aware output behavior, works for all payment methods, and required scope. However, it doesn't explicitly state read-only nature, though implied by 'get'.

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 redundant information.

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

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

For a simple one-param read tool, the description covers purpose, output behavior, and access requirements. It doesn't detail exact return fields, but no output schema exists; the role-aware examples give sufficient expectation.

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 already describes deal_id fully (100% coverage), and description adds no additional parameter details. Baseline 3 applies.

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

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

Clearly states a specific verb and resource: 'Get a role-aware receipt/statement for a marketplace deal.' The role-aware detail distinguishes it from generic list_invoices and other marketplace 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?

Provides clear context on when to use (need a deal-specific receipt) and prerequisites (deals:read scope), but does not explicitly name alternatives like list_invoices for when all invoices are 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?

With no annotations provided, the description carries the full burden. It discloses that each record has a stable id and that a zone_version token is returned, which is crucial for understanding output stability and concurrency behavior. The phrase 'for a domain you own' also implies an ownership requirement, adding behavioral context beyond the schema.

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

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

The description is two sentences, with the main purpose front-loaded in the first sentence. Every sentence adds necessary information: the resource and ownership in the first, return values and relationship to set_dns in the second. No 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 simple tool with one parameter and no output schema or annotations, the description covers all essentials: what it does, who can use it, what it returns, and how the output can be used downstream. The mention of stable id and zone_version is particularly valuable given the lack of an output schema.

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

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

The schema already describes the 'domain' parameter completely, so baseline is 3. The description adds semantic value by indicating the domain must be owned by the user, which is not stated in the schema. This extra constraint helps the agent avoid errors when selecting domains.

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 starts with a clear verb and resource: 'Get DNS records for a domain you own.' It distinguishes this from sibling tools like set_dns (which modifies), dns_check (which verifies external DNS), and get_dnssec (which gets DNSSEC data) by narrowing scope to owned domains and emphasizing the read-only nature of the action.

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 a common workflow by mentioning 'pass it to set_dns to detect concurrent zone changes,' which tells the agent when this tool is useful as a precursor to updates. It does not explicitly name alternatives or exclusions, but the ownership qualifier ('for a domain you own') sets clear expectations about when it applies.

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

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

No annotations are provided, so the description carries the full burden. The verb 'List' and read-only nature are clear, and the 'domain you own' constraint is disclosed. However, it does not mention what happens if the domain is not owned, whether an empty result is returned if DNSSEC is disabled, or any authorization requirements. This is acceptable for a simple read tool but lacks deeper behavioral disclosure.

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 action ('List'), and every phrase adds value. It includes a cross-reference to set_dns without extra fluff, making it highly efficient and well-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?

For a simple read operation with a single parameter and no output schema, the description covers what the tool does, what it returns (DS records, DNSSEC status), and the ownership prerequisite. It also provides broader context (DANE integration), making it complete for its 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 100%, with the 'domain' parameter described as 'Domain name to inspect'. The description adds the ownership requirement ('a domain you own') and specifies output content (DS records and enabled status), which goes beyond the schema. This adds meaningful semantic value, though the parameter format is not elaborated.

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 DNSSEC DS records and indicates whether DNSSEC is enabled. The verb 'List' and resource 'DNSSEC delegation-signer (DS) records' are specific, and the scope 'for a domain you own' distinguishes it from siblings like get_dns, add_dnssec, or delete_dnssec.

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 for inspecting DS records and DNSSEC status on an owned domain. It also suggests pairing with TLSA records via set_dns for DANE, providing a complementary usage. However, it does not explicitly exclude alternatives or state when not to use it, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It states the tool 'Checks' and 'Returns', implying a read-only operation without side effects. It also discloses the specific outputs (record status and mailbox count), which adds valuable behavioral context beyond just the operation name.

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 sentence with two clauses, front-loading the action and outcome. Every word contributes: it specifies what is checked, what is verified, and what is returned. No unnecessary filler or redundancy exists.

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

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

Given the tool's low complexity (1 parameter, no output schema), the description is complete. It explains the purpose, what is checked, and what the return includes (record status and mailbox count). No additional context is needed for an agent to invoke this 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?

The input schema already provides 100% coverage for the single 'domain' parameter with a clear description. The tool description only repeats 'domain' without adding new meaning, so the schema does the heavy lifting. According to the rubric, this warrants a baseline score of 3.

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

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

The description uses the specific verb 'Check' and clearly identifies the resource ('email enabled on a domain', 'DNS records verified'). It distinguishes itself from sibling tools like 'check_email' (which targets individual email addresses) by focusing on domain-level email status.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'check_email' or 'check_email_deliverability'. The description implies usage but does not state exclusions or name alternative tools for different scenarios, leaving the agent to infer the appropriate context from the tool's 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?

Without annotations, the description carries the burden of behavioral disclosure. It accurately conveys a read-only get operation and enumerates the kind of information returned, which sets expectations. It does not mention error cases or ownership verification, but the 'get' verb and scope make the behavior sufficiently 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 is a single, well-structured sentence that starts with the action and object, then efficiently lists the notable data points. Every phrase adds value with no redundancy or filler.

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

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

Given the simple input schema and absence of an output schema, the description covers the essential aspects: what the tool does, the ownership requirement, and the kind of fields returned. It does not discuss edge cases or provider-specific behavior, but for a read-only getter this is sufficient. It could be slightly enhanced by stating return format or clarifying what 'provider data' includes.

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 fully describes the single 'domain' parameter, so the baseline is 3. The description adds the meaningful nuance that the domain must be owned, which is not present in the schema description and helps the agent understand the parameter's semantics more precisely.

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 gets detailed information about a domain, and lists specific data types (auto-renew status, security lock, WHOIS privacy, provider data). This distinguishes it from siblings like get_dns or whois_lookup, which focus on narrower or different aspects.

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

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

The phrase 'a domain you own' provides a clear usage context, indicating this is for owned domains. While it does not explicitly name alternatives or exclusions, the ownership qualifier effectively guides the agent away from whois_lookup or other domain inspection tools.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It states that data is cached for 7 days, which is a meaningful behavioral detail, but it does not mention other aspects like network behavior, failure modes, or authorization requirements. This is adequate but not rich.

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

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

The description is two sentences, front-loads the purpose, and includes a relevant caching note. Every sentence earns its place 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?

This is a simple, single-parameter read tool with no output schema. The description compensates by listing the returned metadata fields and noting the cache duration. It is largely complete, though it does not address what happens for unavailable domains or missing metadata, which is a minor 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 single parameter 'domain' is fully described in the schema with an example. The description merely restates the domain concept without adding extra semantic value beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('website preview metadata'), explicitly lists the returned fields (title, description, image, favicon), and clarifies the use case for taken domains. This clearly distinguishes it from sibling 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?

It provides clear context by stating the tool is useful for understanding what a taken domain is currently used for. However, it does not explicitly mention when to avoid it, alternatives, or exclusions, so it falls short of a full 5.

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

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

With no annotations, the description carries the full burden. It discloses the owner-scoped restriction and clarifies that the readiness score is not an inbox probability, which are meaningful behavioral cues. However, it does not explicitly state that the operation is read-only or describe potential errors, rate limits, or prerequisites beyond ownership. The provided context is useful but incomplete.

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: it states the purpose, lists components, provides a caveat, and includes the API path. Each sentence adds value, though the API path is an implementation detail that may be slightly extraneous for an AI agent. No clutter, but not as lean as a two-sentence example.

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 there is no output schema, the description does a decent job of outlining the content of the report (DNS readiness, bounce/complaint outcomes, account safety, inbox placement). It also clarifies the interpretation of the readiness score. The main gap is the exact response format or field names, but for a single-parameter tool, the description is fairly 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?

The input schema already has 100% description coverage for the single parameter 'domain'. The description adds minimal meaning beyond the schema, except indirectly indicating that the domain must be owner-scoped. This matches the baseline of 3, where the schema does the heavy lifting.

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

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

The description clearly states the tool gets an 'owner-scoped email health report for a domain' with specific breakdown components (DNS readiness, bounce/complaint outcomes, account safety, inbox placement). The verb 'Get' and resource 'email health report' are specific, and it distinguishes from siblings like check_email_deliverability by describing a comprehensive report rather than a simple check.

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

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

The description implies usage context: it is for domains you own ('owner-scoped') and gives a detailed health report. However, it does not explicitly provide when-to-use vs. alternatives or exclusion conditions. No sibling tools are referenced, leaving the agent to infer when this should be selected over similar tools like check_email_deliverability.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It states that 'Username is the full address; password is an app password', which is critical behavioral context for a mail client setup. It also reveals the API endpoint. However, it does not mention response structure or error cases, but the 'Get' verb implies a read-only operation.

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

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

The description consists of three concise sentences, each adding unique value: purpose, credential format, and API endpoint. No unnecessary filler. It is well-structured and front-loaded with the primary 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?

For a simple getter with two parameters and no output schema, the description provides sufficient context. It explains the purpose, the credential requirements, and the API path. It could mention what fields are returned (e.g., server, ports), but the tool name and 'client-settings' resource imply this. The description is complete enough for an agent to invoke it 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 already describes both parameters ('Hosted mailbox slug' and 'Hosted mailbox domain') with 100% coverage, so the description adds minimal parameter-specific meaning. The only added detail is the note about the address format, but that applies to the mailbox rather than the slug/domain parameters directly. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get IMAP/SMTP settings for a hosted mailbox to configure a mail client'. It uses a specific verb ('Get') and resource ('client settings'), and distinguishes it from sibling tools by focusing on mail client configuration. The explicit API endpoint further reinforces the purpose.

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 usage context: 'to configure a mail client (Apple Mail, Thunderbird)'. It also gives essential setup details (username = full address, password = app password). While it doesn't explicitly name alternative tools or situations to avoid, the use case is specific enough to guide selection among the many sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the response contents (full content, headers, delivery events, attachment URLs) and the API endpoint, which is useful. However, it omits error behavior (e.g., 404 for missing ID), authentication requirements, or any side effects, which keeps it at a mid-level 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?

Two short sentences with the key information front-loaded. No filler or redundant content. The API reference is compact and useful.

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 get-by-ID tool with no output schema, the description covers the main need: what the tool returns. It could be more complete by noting error handling or how the address is constructed from the parameters, but it provides enough context to work effectively. Misses the last point for full completeness.

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 all three parameters (slug, domain, message_id) with clear names and short descriptions, so coverage is 100%. The description adds little beyond confirming 'message_id' is the ID and showing an API path using 'address', but does not explain the relationship between slug/domain and address. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('a single message by ID'), and adds precise details (full content, headers, delivery events, attachment download URLs). It clearly distinguishes from sibling tools like list_email_messages (list vs. single) and delete_message (mutating vs. 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?

The phrase 'single message by ID' provides clear context for when to use this tool—when a specific message is needed. However, it does not explicitly mention when not to use it or name alternatives like list_email_messages for multiple messages, leaving it just below the top score.

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

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

With no annotations, the description carries the full burden. It conveys that the tool returns the authoritative nameservers and that an empty result indicates a serious issue that will break downstream DNS operations. This adds meaningful context beyond the basic 'get nameservers' phrase, though it omits specifics about return format and error cases for invalid or non-owned domains.

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

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

The description is two short sentences. The first sentence immediately states the tool's purpose, and the second provides a valuable caveat about empty results. No words are wasted, and the structure is front-loaded with the primary 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?

For a simple getter with one parameter and no output schema, the description covers the purpose, ownership prerequisite, and the significance of an empty result. It doesn't explicitly state the return format (e.g., array vs. string), but the low complexity and clear intent make it sufficiently complete for an agent to select and invoke 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 schema already documents the only parameter 'domain' with a clear description. The tool description adds 'a domain you own' which is a prerequisite rather than parameter syntax or formatting. Since schema coverage is 100%, the baseline of 3 is appropriate; no additional parameter-level detail 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 uses a specific verb 'Get' with a clear resource: 'authoritative nameservers configured for a domain you own.' This distinguishes it from sibling tools like get_dns (which likely returns all DNS records) and set_nameservers (which modifies them). It also specifies ownership scope ('a domain you own'), which further clarifies its purpose.

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

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

The phrase 'for a domain you own' signals a prerequisite for use, and the warning 'If empty, DNS operations (parking, email, connect) will fail' implies when this tool should be used (e.g., before DNS operations to verify nameserver configuration). However, it does not explicitly mention alternatives or exclusions, such as preferring get_dns for full DNS record inspection.

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

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

With no annotations provided, the description carries the full burden of disclosure. It accurately conveys a read-only analytics operation and details the output components, which is transparent enough for the simple read context. It lacks mention of prerequisites (e.g., domain must be parked) or possible error states, but the behavior is otherwise clear.

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

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

The description is two sentences long, with the first listing the tool's output and the second giving the practical use case. Every word earns its place, and key information 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 the tool's simplicity (one parameter, no output schema), the description is complete. It specifies exactly what data the agent will receive, which is sufficient for an analytics retrieval tool. 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 description coverage is 100% for the single 'domain' parameter, which already has a clear example. The description adds the qualifier 'parked domain,' providing slight extra context, but the baseline of 3 applies since the schema already documents the parameter effectively.

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 with a specific verb ('Get') and resource ('visitor analytics for a parked domain'), and enumerates the exact data returned (page views, inquiries, conversion rate, daily breakdown, recent inquiries). It distinguishes itself from sibling tools by focusing solely on analytics, not domain management or DNS.

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 a clear use case: 'check how much traffic a parked domain gets and whether it's converting into buyer inquiries.' This tells the agent when to use the tool, though it does not explicitly mention alternatives or when not to use it. That prevents a 5.

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

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

No annotations are provided, so the description carries the full burden. 'Check the status' implies a read-only operation, but the description does not disclose the response format, authentication requirements, or potential edge cases like invalid domains. The behavioral traits are left largely implicit.

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 concise sentences, front-loaded with the verb and resource. Every word earns its place, with no redundant or vague phrasing.

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 status check, the description covers what the tool does and when to use it. The lack of an output schema does not significantly hurt, as the purpose is straightforward. A brief note on possible status values would round it out, but it's not essential.

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 a clear property description ('Domain to check transfer status for'). The tool description adds no extra semantics beyond the schema, but none are necessary given the single self-explanatory parameter. Baseline 3 is appropriate.

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

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

The description clearly states the function: 'Check the status of an outbound domain transfer.' It specifies the resource as outbound domain transfers, which distinguishes it from generic transfer status tools. However, it doesn't explicitly name sibling tools like check_transfer_status, so it stops just short of full differentiation.

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

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

The description provides explicit sequencing guidance: 'Use after getting an auth code and initiating the transfer at the new registrar.' This clearly tells the agent when to use the tool. It doesn't mention exclusions or alternatives, but the context is clear enough.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: the operation is free, does not require a transfer, and returns a TXT record for DNS verification. However, it does not mention that a follow-up verification step (e.g., verify_import) is required or describe any side effects or limitations, leaving some process ambiguity.

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

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

The description is two sentences long, front-loaded with the primary purpose, and every clause adds value—ownership context, cost, transfer avoidance, and the TXT record response. No redundant or filler content.

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

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

For a simple one-parameter tool with no output schema, the description adequately covers what the tool does, when to use it, and what the immediate response will be. It misses the tie-in to the sibling verify_import tool, which could create a gap in the overall workflow, but the core usage is sufficiently 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?

The input schema already provides a clear description for the single 'domain' parameter with an example. The tool description adds the context that the domain must be externally owned, but does not add further syntax or formatting details. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: importing an external domain the user already owns, with the explicit distinction 'no transfer needed.' This differentiates it from sibling tools like transfer_domain or acquire_domain. The verb 'import' and resource 'external domain' are specific and unambiguous.

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

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

The description gives clear usage context: for domains already owned at another registrar, and explicitly excludes transfer by saying 'no transfer needed.' It does not name alternative sibling tools directly, but the context is sufficient for an agent to choose this over transfer-related tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context by specifying 'newest first' ordering and enumerating the event types included. It does not contradict annotations (there are none) and provides a clear picture of what to expect.

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 core purpose, and every word adds value. It is neither verbose nor under-specified.

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

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

For a read-only list tool with two optional parameters and no output schema, the description adequately covers what events are returned and their ordering. It could be more explicit about the response structure (e.g., individual event fields), but overall it is complete enough for effective use.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds some context around event types (e.g., token lifecycle, denials) that could inform the 'type' parameter, but it does not directly explain the parameters or their syntax beyond what the schema already provides.

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

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

The description clearly states this is the account's security audit trail, listing specific event categories (token lifecycle, denials, charges, payouts). It uses a specific verb and resource, and the scope ('account's') distinguishes it from other list tools like list_tokens or list_invoices.

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 says 'Use it to review what the account's tokens have been doing,' providing clear usage context. It does not mention exclusions or alternative tools, but the intended use case is evident.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and statuses, omitting that this is a read-only operation, what the return format is, or whether all statuses are included by default. This is minimal behavioral context.

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

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

The description is a single, front-loaded sentence that efficiently states the action, resource, and optional status filter. The statuses are compactly listed in parentheses, and there is no unnecessary information.

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

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

For a simple read-only list tool with one optional parameter, the description covers the core purpose and filtering. However, without annotations or an output schema, it lacks explicit details about return structure, default behavior when no status is provided, or any pagination concerns, leaving some 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 input schema already fully describes the 'status' parameter with an enum and the description 'Filter by status.' The tool description only echoes this same capability without adding new meaning, so it adds no value beyond the schema (which has high 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 action ('List') and the resource ('the user's backorders'), enumerating the exact statuses. It distinguishes itself from sibling tools like create_backorder or cancel_backorder by specifying this is a listing 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 clear context for when to use the tool (to list backorders) and mentions the optional status filter. It doesn't explicitly name alternatives or exclusions, but no sibling tool directly competes for this listing task, so the usage is well implied.

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

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

With no annotations provided, the description carries the full burden. It discloses an authentication requirement ('Requires deals:read scope') and enumerates the possible statuses ('sourcing/contacted/negotiating/agreed/no_contact/declined'), which helps set expectations about the response content. However, it does not mention pagination, default behavior when parameters are omitted, or explicitly confirm read-only behavior, though 'List' implies non-mutating.

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, well-structured sentence that front-loads the primary purpose, then provides the status list and auth requirement. Every piece of information contributes value, and there is no redundancy or filler. It is concise without sacrificing clarity.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description is reasonably complete. It specifies the resource, the status values, and the required scope. Minor gaps include lack of detail on default filtering when no status is provided and no mention of pagination, but these are not critical for a straightforward list operation. The description covers the essential 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?

The schema covers the single parameter 'status' with 'Filter by status, or 'all'', but the description adds the full list of allowed statuses (sourcing/contacted/negotiating/agreed/no_contact/declined), which the schema does not include. This extra context significantly enhances parameter understanding, beyond the 100% schema coverage baseline.

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

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

The description uses a specific verb ('List') with a clear resource ('your domain acquisition requests') and explicitly states the scope ('their status'). This distinguishes it from sibling tools like list_negotiations or get_broker_inquiry_state, which focus on different or singular aspects. The wording is unambiguous and directly states what the 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 implies usage: use this tool to list your own acquisition requests. It mentions the required scope (deals:read), which is a prerequisite, but does not explicitly state when to prefer this tool over alternatives or when not to use it. No exclusions or alternative recommendations are provided, so the guidance remains implicit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not specify output format, pagination, or whether all domain statuses are included, leaving some ambiguity.

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

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

The description is a single sentence of five words, front-loaded with the action and resource. Every word earns its place, with no filler or redundancy.

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

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

For a zero-parameter tool with no output schema, the description covers the essential purpose but lacks detail on return values and any filtering options. Given the tool's simplicity, it is sufficiently complete, though a note about the output structure would improve 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?

There are zero parameters and the schema is an empty object, so the description has no parameter documentation burden. The description correctly focuses on the tool's purpose rather than parameters, earning the baseline score of 4.

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' and identifies the resource as 'domains you own', clearly stating the tool's purpose. However, it doesn't differentiate from other list tools like list_services or list_tlds, so not quite a 5.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_domain_info or list_services. The description lacks context, alternatives, or exclusions, leaving the agent to infer usage solely from the tool 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?

The description discloses the HTTP method (GET) and the data returned, including counts and capabilities, which helps infer a read-only operation. However, it does not explicitly state authentication requirements, rate limits, or other behavioral constraints, and there are no annotations to supplement this.

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, consisting of two sentences: a clear summary of what the tool does and the API endpoint. Every word earns its place, and the primary 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?

Given the absence of an output schema and annotations, the description does a good job by enumerating the response categories (folders, views, counts, capabilities). It could be enhanced by specifying the response shape or any pagination behavior, but for a simple list tool it is sufficiently 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?

Both parameters have descriptions in the input schema (100% coverage), so the schema already documents 'domain' and 'slug'. The tool description does not add any additional meaning or context about how these parameters are used, 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 explicitly states the tool 'List canonical mailbox folders, virtual views, server-derived total/unread counts, and backend capabilities,' which is a specific verb+resource with clear scope. The API endpoint is included, and it is clearly distinguishable from sibling tools like list_email_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?

No explicit guidance is given about when to use this tool over alternatives. The usage is implied by the name and the description of listing folders, but there are no exclusions or references to sibling tools for comparison.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It mentions the GET API endpoint and default Inbox, which implies a read-only operation, but does not explicitly state read-only behavior, auth requirements, or response details. It adds some context but lacks full 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 two sentences long, front-loaded with the primary purpose, and contains no unnecessary words. It is efficient and well-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?

Given 11 parameters and no output schema, the description covers the default folder and high-level filter capabilities but omits details about response structure, pagination cursor usage, and parameter exclusions (e.g., view/folder mutual exclusivity, which is left to the schema). It is adequate but not comprehensive.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions pagination, direction, and search filters, which align with schema parameters, but adds no new meaning beyond what the property descriptions already provide.

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

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

The description clearly identifies the tool as listing email messages within a system folder or virtual view, with a default to Inbox. This distinguishes it from sibling tools like list_mailboxes (which lists mailboxes) and get_message (which retrieves a single 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 imparts clear context: it is for listing messages in a folder/view with pagination and filters. It does not explicitly mention when not to use it or suggest alternatives like get_message for single messages, but the scope is 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 no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, and the scope 'you've claimed' adds useful context about the returned data. However, it does not explicitly state that the operation has no side effects, nor does it describe pagination, ordering, or error behavior. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler words. It directly states the action and scope, making it highly efficient and easy to parse. Every word earns its place.

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

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

For a zero-parameter list tool with no output schema, the description is complete. It specifies exactly what is returned (claimed free agent identities) and the format hint (<handle>.domani.run). The tool's simplicity means no additional context is needed; the description fully covers the task.

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 description coverage is 100% (empty properties). The baseline for zero parameters is 4, and the description does not need to add parameter-level detail since there are none. It correctly avoids inventing unnecessary parameter information.

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

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

The description clearly states the tool lists 'free agent identities (<handle>.domani.run) you've claimed.' It uses a specific verb (list) and resource (claimed identities), and distinguishes from siblings like claim_identity and release_identity by specifying the scope. This is a precise and unambiguous definition.

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 viewing identities the user has already claimed, which distinguishes it from other identity-related tools. However, it does not explicitly mention alternatives or when not to use it. The context is clear but lacks explicit exclusions or alternative guidance, so it earns a 4 rather than a 5.

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

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

With no annotations, the description carries the transparency burden. It discloses the return content (invoice number, amount, date, PDF links) and the generation source (Stripe on domain purchases/renewals/transfers). It does not mention ordering, status filters, or pagination beyond the schema's limit parameter, but for a simple read operation this is reasonably 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 is two sentences with the core action front-loaded. Every sentence adds value: the first states the purpose and return fields, the second explains when invoices are created. No fluff or redundancy.

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

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

For a simple list tool with one optional parameter and no output schema, the description is complete. It explains what the tool returns and why invoices exist, covering the essential context needed for an agent to invoke it 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 fully documents the only parameter (limit) with min, max, default, and description (100% schema coverage). The description adds no additional parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the tool's purpose: 'List the user's payment invoices.' It goes beyond a tautology by specifying the returned fields (invoice number, amount, date, PDF links) and the context (Stripe invoices for domain purchases, renewals, transfers). This distinguishes it from other list tools like list_domains or list_services.

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

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

The description provides clear context on when invoices are generated, implying when this tool would be useful (billing history for domain transactions). However, it does not explicitly contrast with alternative tools or state exclusions, though no direct sibling tool overlaps with this resource.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the basic list operation and gives an API endpoint, but does not disclose potential side effects, required permissions, pagination behavior, or error conditions—significant gaps for a tool with no annotation support.

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

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

The description is two short sentences, front-loaded with the core purpose, and includes the API endpoint as a useful technical reference. No 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?

The tool is simple and the schema fully documents parameters, but there is no output schema and no annotations. The description implies the return value (a list of alias addresses) but does not mention pagination, ordering, or potential error responses, leaving some contextual 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 100%, with clear descriptions for both 'slug' and 'domain'. The description does not add meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the operation: 'List all alias addresses that deliver into a mailbox.' This uses a specific verb and resource, and distinguishes the tool from sibling tools like add_mailbox_alias and remove_mailbox_alias.

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 when to use the tool: when you need to see all aliases for a mailbox. It does not explicitly exclude alternatives or state when not to use it, but the context is clear and there are no competing list tools for mailbox aliases.

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

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

With no annotations provided, the description carries the burden of disclosure. It explains the opaque cursor behavior, the need to call without a cursor first, and the replay pattern. However, it does not describe the return format or what 'changes' includes, leaving some ambiguity about the response. Still, the core sync behavior is well conveyed.

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 core purpose, and every word adds value. It efficiently explains the sync protocol and includes the API endpoint without waste.

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 and no annotations, the description covers the main invocation pattern (cursor sequencing) and the API path. It lacks explicit return value details, but the mention of next_cursor implies response includes it. For a sync tool, this is reasonably complete, though a bit more on response contents would help.

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 67% (cursor and mailbox_id have descriptions; limit does not). The description adds understanding of the cursor as opaque and tied to next_cursor, and hints at bounded full snapshot implying limit usage. However, it does not elaborate on limit's range or default, and the added semantics are moderate.

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

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

The description states the tool performs incremental mailbox synchronization using an opaque cursor, which is a specific verb+resource combination. It clearly distinguishes itself from siblings like list_email_messages by focusing on change replay rather than simple listing, and the API endpoint is provided.

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 sequencing instructions: call without a cursor for a bounded full snapshot, then replay changes from next_cursor. It implies the tool is for incremental sync, but does not explicitly mention when not to use it or alternative tools, so it misses the full 'when-not/alternatives' bar.

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