instadomain

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

With no annotations, the description carries the full burden. It discloses that the tool creates a Stripe checkout session, explains why registrant details are required (legal ownership), notes WHOIS privacy, and lists return fields. It does not address failure modes or whether funds are charged immediately, but the core behavior is transparent.

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

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

The description is long, but every section earns its place: critical warnings, parameter explanations, and return values. It front-loads the most important prerequisite. Minor redundancy exists with the repeated 'IMPORTANT' emphasis, but overall structure is clear and actionable.

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

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

The description covers the complete transactional context: prerequisite check, user confirmation, registrant rationale, payment method, and required post-action. The Returns section complements the existing output schema. It does not cover error handling, but that is not critical given the rich guidance provided.

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

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

Schema description coverage is 0%, but the Args section gives meaningful descriptions for all 11 parameters, including an example for domain, a format for phone, and explicit optionality for org_name. This fully compensates for the schema's lack of per-field documentation.

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

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

The description opens with 'Start the purchase flow for an available domain via Stripe checkout,' which clearly identifies the action, resource, and payment method. It differentiates from sibling tools like buy_domain_crypto and buy_domain_mpp by specifying Stripe, and the word 'available' implies a prerequisite 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?

Provides explicit, mandatory usage instructions: call check_domain first, show the price to the user, obtain explicit confirmation, and never call without approval. It also dictates the post-return action of opening the checkout_url, making the transactional flow 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 the full burden of behavioral disclosure. It reveals that this tool only reserves and returns a pay_url, that payment happens externally via x402/curl, that no browser is required, that registrant details become public WHOIS (though privacy is enabled), and that polling is needed for completion. This is comprehensive for a financial mutation tool.

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

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

The description is organized with numbered steps, an IMPORTANT note, and labeled Args/Returns sections. Every sentence adds operational value, and the length is justified by the tool's complexity. There is 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?

The description covers the entire lifecycle: prerequisite price check, reservation step, payment execution options, post-payment polling, legal ownership context, input parameter formats, and return fields. For a multi-step purchase flow with no annotations, this is nearly complete and leaves the agent well-equipped to invoke and follow through.

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

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

Schema description coverage is 0%, but the Args section thoroughly documents all 11 parameters with meaningful semantics: formats for phone and country, optional org_name, example for domain, and clear labels for registrant fields. This fully compensates for the bare schema, making parameter usage unambiguous.

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 action: 'Start the purchase flow for a domain using USDC crypto payment (x402 protocol).' It names the resource, the verb, and the payment method, clearly distinguishing it from sibling tools like buy_domain and buy_domain_mpp by emphasizing crypto/x402 and the two-step flow.

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

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

The description gives explicit when-to-use guidance: 'Before calling this tool, you MUST first call check_domain to get the price and confirm it with the user.' It also details the post-payment step (poll get_domain_status) and provides alternative payment methods (Coinbase MCP or curl), giving the agent a complete operational sequence.

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 that payment is charged via Stripe, that domain registration is kicked off, and that the client must handle HTTP 402/SPT flow. It does not mention refunds or failure modes, but given the tool is just starting a flow, the transparency is strong.

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 average but earns its length by explaining a complex protocol. It is well-structured with separated paragraphs, a numbered two-step flow, and a clear Args/Returns breakdown. No sentence is superfluous, though it could have trimmed the exact HTTP handshake details without losing utility.

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 the MPP flow, the description is exceptionally complete: it covers prerequisites, exact step-by-step interaction, return fields, and points to the next tool (get_domain_status). The presence of an output schema also means return value details are redundant, but the description still outlines them, making it self-contained.

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

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

Schema description coverage is 0%, so the description compensates by listing all parameters with some additional semantics: domain gets an example, phone gets a format, country gets '2-letter ISO', and org_name is flagged optional. Some entries like 'Registrant's first name' are slightly redundant but still add ownership context.

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

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

The description clearly states 'Start the purchase flow for a domain via Stripe's Machine Payments Protocol (MPP)', which names a specific verb, resource, and protocol. It distinguishes itself from siblings like buy_domain and buy_domain_crypto by detailing the MPP-specific two-step flow and prerequisites.

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 and prerequisites: it requires an MPP-compatible client and explains the two-step flow. It also points to get_domain_status as the follow-up tool. However, it does not explicitly mention alternative tools (e.g., buy_domain_crypto) for cases where MPP is not suitable, 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 full burden. It reveals the workflow (check, ask, route), the return format (availability, price in cents), and notes that crypto payment is 'autonomous' while others open a browser. It doesn't mention authentication or error conditions, but for a read-only check tool this is sufficient 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 more verbose than the average tool but every sentence earns its place. It front-loads the purpose, then uses a numbered list and bullet points for workflow steps. The length is justified by the complex decision logic, though it could be slightly tightened.

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 a single parameter and a rich output schema, the description provides all needed context: it explains when to use it, how to interpret results, how to interact with the user, and which sibling tool to call next. It even includes a conditional recommendation based on MCP configuration. The only minor omission is prerequisites like authentication, but that is likely assumed in the suite.

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

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

The schema has zero description coverage, but the description fully compensates by defining the parameter: 'The full domain name to check (e.g. "coolstartup.com")'. It also explains the return value, making the single parameter's meaning entirely 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 opens with a clear verb and resource: 'Check if a domain is available for purchase and get its price.' It also distinguishes itself from siblings by stating 'Always call this before buying' and listing the buy_domain variants, making its role as a pre-purchase check explicit.

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

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

It provides explicit when-to-use instructions: 'Always call this before buying.' It further details exactly what to ask the user after showing the price and routes to specific sibling tools (buy_domain, buy_domain_crypto, buy_domain_mpp) based on payment method, including a default decision rule for Coinbase MCP.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that this is a read-only RDAP lookup ('no pricing'), clarifies it returns a summary with counts and per-domain details, and implicitly contrasts with purchase tools. It does not mention rate limits or error handling, but for a simple availability check, the provided transparency is solid.

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 leads with the core purpose, adds a key behavioral detail (RDAP, no pricing), describes the return summary, and then provides a clear Args section. Every sentence earns its place with no fluff.

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

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

For a simple one-parameter tool with an output schema, the description is largely complete. It specifies the maximum domain count, the return summary structure, and the per-domain details. It doesn't cover edge cases like invalid domain formats or error behavior, but given the low complexity and presence of an output schema, 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?

The input schema only declares 'domains' as an array of strings with no description. The description compensates fully by explaining 'List of domain names to check (max 50)' and reiterating the 'up to 50' limit, adding meaning beyond the schema. This is critical because schema coverage is 0%.

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: 'Check availability of up to 50 domain names in one call.' It distinguishes itself from sibling tools such as check_domain (single check) and buy_domain by emphasizing the bulk nature and the use of RDAP lookups without pricing.

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: use this for bulk availability checks ('up to 50 domain names in one call', 'fast RDAP lookups (no pricing)'). It does not explicitly name alternative tools or provide when-not-to-use guidance, but the bulk vs. single distinction is clear from the sibling list and the phrase 'in one call'.

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 explicitly discloses polling every 3 seconds up to 120 seconds until terminal states (complete or failed). This is valuable behavioral detail beyond just 'get status.' However, it doesn't specify behavior on timeout after 120s or error handling, 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 compact and front-loaded with the core purpose. It includes only essential information: the purpose, polling behavior, and parameter explanation. No redundant sentences or vague 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 a simple single-parameter tool with an output schema, the description covers the key behavioral aspects: polling, timeout limit, terminal states. It doesn't explain what happens if the order doesn't reach a terminal state within 120 seconds, but the presence of an output schema likely documents return values. The overall context is sufficiently complete for an agent to use 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 schema only defines order_id as a string, but the description adds crucial semantics: it is 'The order ID returned from buy_domain' with an example format 'ord_abc123'. This fully explains the parameter's origin and format, compensating for the 0% schema description 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 opens with a specific verb+resource phrase: 'Get the status of a domain purchase order.' It clearly distinguishes from sibling tools like check_domain (which checks domain availability) and buy_domain (which initiates purchases) by focusing on order status. The polling behavior further clarifies its 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?

The description implies usage after buy_domain by stating the order_id comes from buy_domain, e.g. 'ord_abc123'. It provides context that this is for tracking purchase order progress, which implies not for domain availability checks. However, it lacks explicit exclusions or mention of alternative tools for different 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?

No annotations are provided, so the description carries the full burden. It does not disclose whether the transfer_token is consumed, whether the operation has side effects, or what happens if the token is invalid. The verb 'Get' implies a read, but this is not explicitly stated.

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

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

The description is concise and well-structured: a one-line purpose, a prerequisite note, and clearly labeled parameter descriptions. Every sentence contributes value without redundancy.

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

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

Given the simple 2-parameter tool and the existence of an output schema, the description covers the essential context: purpose, prerequisite (transfer_token), and parameter semantics. It does not need to explain return values due to the output schema. It could mention error conditions, but overall it 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?

Schema description coverage is 0%, but the description fully compensates by explaining both parameters: 'order_id: The order ID of a completed domain purchase' and 'transfer_token: Token returned by verify_transfer_code.' This adds significant meaning beyond the bare schema types.

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

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

The description clearly states the tool retrieves the EPP/transfer authorization code for a completed domain purchase. It distinguishes itself from sibling tools by specifying the requirement of a transfer_token from verify_transfer_code, implying a specific workflow.

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 by stating it 'Requires a transfer_token from verify_transfer_code' and that order_id must be from a completed purchase. However, it does not explicitly state when to use this tool versus alternatives like request_transfer_code, nor does it provide 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?

No annotations are provided, so the description carries the full burden. It discloses a key behavior—creating a Stripe checkout session—which goes beyond a simple 'renew' action. It also specifies the prerequisite of a completed purchase order ID. However, it does not describe post-payment behavior, potential failures, or reversibility.

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

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

The description is concise, with two purposeful sentences plus an Args section. It is front-loaded with the primary purpose and contains no filler 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 tool with one parameter and an output schema, the description covers the essential context: the renewal duration, the payment mechanism, and the required input. It could mention what happens after checkout, but the core usage is clear and 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 coverage is 0%, but the description fully documents the only parameter, order_id, by explaining it as 'the order ID of a completed domain purchase' and providing an example. This adds semantic meaning beyond the raw schema.

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

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

The description clearly states the action: 'Renew a domain for 1 additional year,' which is specific and distinguishes it from sibling tools like buy_domain or check_domain. The verb and resource are explicit.

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

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

The description implies when to use the tool (for domain renewal) but does not explicitly state when not to use it or mention alternatives. There is no exclusionary guidance, so it stays at an implied level.

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 and it discloses a key side effect (sending an email to the registrant) and the fact that the code is not returned but must be obtained from the user. It adds behavioral context beyond the schema and name, though it omits details like error conditions 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?

The description is tight and well-structured: a one-sentence purpose, a clear bullet-like flow, and a concise args section. Every sentence adds value 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 simple one-param tool with no annotations, the description adequately explains the tool's role in the broader flow and the required next steps. It doesn't explain the output, but an output schema exists, so that's acceptable. Some minor gaps like rate limits or re-sending behavior prevent a 5.

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

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

Schema coverage is 0% and the description compensates by explaining 'order_id: The order ID of a completed domain purchase.' This adds meaning beyond the schema's bare string type, making the parameter's purpose and prerequisite 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 'Start the transfer verification flow by sending a code to the registrant's email' which is a specific verb+resource+action. It distinguishes from siblings by positioning itself as the initial step in a multi-step flow, explicitly naming the order of calls.

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 get_transfer_code or unlock_domain' and provides the subsequent steps: ask user for the code, then call verify_transfer_code. This gives clear when-to-use and ordering guidance relative to alternatives.

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It indicates a non-mutating operation (generate and check availability), which is positive, but does not explicitly state that it does not purchase/reserve domains, nor mention any limitations or side effects. This is a moderate gap.

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

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

The description is compact and front-loaded, stating the main purpose in the first sentence and clarifying the parameter in the second. Every sentence contributes value 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?

Given the tool's simplicity (one parameter) and that an output schema exists, the description covers the core function and parameter meaning. It does not describe return values, but the output schema likely handles that, so completeness 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 description coverage is 0%, so the description must clarify parameters. It adds useful semantics for 'keyword' ('a keyword or short business name') with an example ('taskflow'), which compensates well for the schema's lack of description.

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 specific verbs ('Generate', 'check') and a resource ('domain name ideas'). It distinguishes itself from sibling tools by emphasizing generation from a keyword, which is unique compared to buy/check/transfer operations.

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

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

The description implies usage for brainstorming domain names from a keyword, but does not explicitly state when to use this tool versus check_domain or check_domains_bulk. No exclusions or alternatives are mentioned, so guidance 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, so the description carries the full behavioral burden. It discloses the action and the token dependency but does not mention side effects, reversibility, or whether the operation is destructive. As a mutating tool, this lack of detail is a noticeable gap.

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

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

The description is concise and well-structured: two sentences of purpose and context plus a two-item argument list with explanations. Every sentence adds value and there is no irrelevant 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 two-parameter tool with an output schema, the description covers essential context: what it does, what inputs are needed, and where they come from. It omits error-handling or workflow steps, but the low complexity makes that acceptable.

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

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

The schema provides only parameter names and types, with 0% description coverage. The description compensates by explaining that order_id is the ID of a completed domain purchase and transfer_token is the token returned by verify_transfer_code. This adds meaningful semantics beyond the schema.

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

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

The description opens with 'Remove the registrar transfer lock,' a specific verb and resource that clearly identifies the tool's function. It also references verify_transfer_code, distinguishing it from sibling verification tools. This is unambiguous and action-oriented.

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 states that a transfer_token from verify_transfer_code is required, establishing the tool's place in the domain purchase flow. It also specifies order_id must relate to a completed purchase, providing a clear precondition. It does not explicitly list alternatives but the context is sufficient.

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

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

No annotations are present, so the description carries the full behavioral burden. It discloses the 15-minute token validity and the 6-digit code format, which go beyond the schema. However, it does not state what happens on an invalid code or whether the token is single-use.

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

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

The description is concise, with the primary action stated first, followed by usage context and an Args list. Every sentence adds value and there is no unnecessary 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?

The description covers the trigger action, required parameters, token validity, and next steps with sibling tools, providing a complete workflow context. An output schema exists, so return value details are not required in the 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?

The schema provides no parameter descriptions (0% coverage), but the description's Args section explains both order_id ('The order ID of a completed domain purchase') and code ('The 6-digit code from the verification email'), fully compensating for the schema gap.

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

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

The description clearly states the tool verifies an email code and returns a transfer token. It distinguishes itself from siblings by explicitly referencing request_transfer_code, get_transfer_code, and unlock_domain in the workflow.

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 'Call this after request_transfer_code and the user provides their code' and instructs passing the returned token to get_transfer_code or unlock_domain, giving clear sequencing and alternative next steps.

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