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

With no annotations provided, the description carries the full behavioral disclosure burden. It meaningfully reveals the financial side effect (refund only if no SMS was received) and the API key requirement. It could further clarify irreversibility or behavior when already completed, but the core side effect 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 short and front-loaded, with the core action first followed by the important refund caveat. 'Requires an API key' is slightly generic but not excessive. Overall it is well-structured with no substantial 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?

This is a simple one-parameter tool with no output schema, and the description covers the action, the main side effect, and an auth requirement. It does not address edge cases like cancellation after completion, but it is largely complete for the tool's complexity.

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

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

Schema description coverage is 100%, and the schema already defines id as the activation id. The description adds little beyond the schema's own parameter documentation, 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-resource pair, 'Cancel an activation', which clearly identifies the tool's operation. It also adds a key semantic detail about refunding the wallet, making it distinguishable from sibling tools like complete or email_cancel.

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 general context (cancelling an activation and the refund condition) but does not explicitly contrast with alternatives or state when cancellation should not be used. There are no exclusions or alternative-tool routing.

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 responsibility for disclosing behavioral traits. It mentions 'Final transition' suggesting irreversibility, but it does not explicitly state side effects (e.g., whether it consumes the activation, affects balance, or is irreversible). It also does not describe what happens on success or failure, or any response format. The API key requirement is a minimal authentication note but not sufficient behavioral 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 very concise—two short phrases and a requirement note. It front-loads the primary action and includes the essential prerequisite (API key). Every word earns its place, with no waste 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 operation with one parameter and no output schema, the description is largely adequate. It states the purpose and the prerequisite. However, it does not disclose the outcome (what it returns or whether it is reversible), which an agent might need to know. Given the absence of annotations, more detail on side effects would improve completeness, but it is not severely lacking.

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 the only parameter 'id' with a description ('Activation id (from request_number or list_activations)') at 100% coverage. The tool description adds no additional detail about the parameter, so it meets the baseline of 3 without enhancing understanding beyond the schema.

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

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

The description clearly states the action: 'Mark an activation complete' and adds context that it confirms the SMS was used. It distinguishes itself from siblings like cancel by calling it the 'Final transition,' which implies it is the conclusion of a successful activation. However, it could be more explicit about how it differs from cancel or other operations, so it misses a perfect score.

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 some context on when to use it ('confirms the SMS was used', 'Final transition') which implies it is used after a successful SMS delivery. It does not explicitly state when not to use it or suggest alternatives like cancel, but the context is enough to infer typical usage. The mention of requiring an API key is a prerequisite, not a usage guideline.

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 behavioral burden and it does so well: it discloses the consequential refund side effect ('Refunds the wallet if no OTP was received') and the API-key prerequisite. It stops short of stating irreversibility or state restrictions, but the verb 'cancel' already implies the destructive nature.

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 cover the core action, a key side effect, and an auth requirement without filler. The purpose is front-loaded in the first sentence, and every sentence earns its place.

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

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

For a single-parameter mutation with no output schema, the description covers the action, financial side effect, and authentication requirement. It leaves the success/error response and state constraints unspecified, but the tool is simple enough that the agent has what it needs to call 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%: the input schema already identifies 'id' and tells the agent it comes from email_request or email_list. The description adds no further parameter semantics, 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 opens with a direct verb and concrete resource: 'Cancel an email activation.' This matches the tool name and title and clearly separates the tool from the generic sibling 'cancel' by targeting the email-activation 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 action 'Cancel an email activation' implies when to use it, and the refund condition adds context about the scenario. However, it does not explicitly compare with siblings such as 'complete' or 'cancel', nor state any when-not-to-use conditions, so the guidance is 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 behavioral burden. It discloses the API key requirement and explicitly states 'Does not spend,' which is valuable for an agent deciding whether the call is safe. It does not mention response format or error/rate-limit behavior, but for a read-only listing tool this is a reasonable 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?

Three short sentences, each with a distinct purpose: what the tool does, what is required, and where it fits in the workflow. No filler or repetition of schema details.

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 one-parameter list operation, the description covers purpose, prerequisites, workflow placement, and the non-spending behavior. It does not describe the exact output shape, but it does mention the key output contents (prices and stock), making it sufficiently complete for an agent to invoke the 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 input schema already fully documents the single parameter ('site') with an example and pattern. The description adds no new parameter-level detail, so the baseline of 3 applies since schema coverage is 100%.

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

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

The description states a specific verb ('List'), a precise resource ('available email provider domains'), and the relevant details (prices, stock, target site). It clearly distinguishes this from other email_* operations and identifies the domain-picking 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?

It explicitly says to use this before email_request and notes that it requires an API key, giving clear usage context. It does not explicitly call out when not to use it relative to the many sibling email tools, but the main intended flow 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?

There are no annotations, so the description carries the full burden. It discloses an authentication requirement ('Requires an API key') and a useful side-effect signal ('Does not spend'), but it does not clarify whether the tool can be polled repeatedly, whether it changes activation state, or what happens before the email is received. These are meaningful gaps for a status 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 short sentences, with the resource and returned values front-loaded and the prerequisite/side-effect included immediately. Every sentence earns its place and there is no redundant 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 single-parameter lookup with no output schema, the description covers inputs, expected outputs, authentication, and the fact that it does not spend. It is slightly thin on explicit usage context relative to sibling tools, but the schema and sibling names fill most of the remaining 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%, and the schema already describes id as the email activation id from email_request or email_list. The description only restates 'one email activation' and adds no extra parameter semantics, so the baseline of 3 is appropriate.

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

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

The description names a specific verb ('Get'), a resource ('one email activation'), and the returned data (status, parsed OTP, raw HTML body). However, it does not explicitly distinguish itself from the sibling get_status; the email-specific wording makes the resource clear, but the differentiation is left implicit.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no alternatives such as get_status or email_list are mentioned. The phrase 'once received' implies this is meant for checking an activation after an email request, but that usage context is only implied, not stated.

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 an excellent job: it discloses the ordering behavior, the 100-row cap, the lack of cursor paging, the API key requirement, and the important side-effect fact that it does not spend. These go well beyond the schema and give the agent a clear behavioral model.

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, each carrying a distinct fact: the core purpose, the paging/limit behavior, and the auth/side-effect notes. The most important information is front-loaded and there is zero filler.

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

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

For a simple, single-optional-parameter list tool with no output schema, this description covers everything an agent needs to invoke it correctly: what it returns (a list of recent email activations), the ordering, the limit, the paging limitation, authentication, and cost side-effects. Nothing obvious is missing.

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

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

Schema coverage is 100% for the single limit parameter, so the schema already documents its range and default. The description's mention of 'up to 100' simply echoes the schema's maximum and adds no new meaning. Baseline 3 is appropriate because the schema handles the parameter semantics.

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

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

The description states a specific action and resource ('List your most recent email activations') and adds concrete scoping details (newest first, up to 100, no paging). The 'email' qualifier clearly distinguishes it from the sibling list_activations, so an agent can tell them apart without opening schemas.

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 clear context about when this tool is appropriate: for listing recent email activations, with limitations (no cursor paging, up to 100) and prerequisites (API key). It does not explicitly name alternatives or state when to use list_activations instead, so it stops short of a full when-not/exclusion guide.

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 two critical behaviors: it spends from the wallet again and requires an API key. However, it does not mention side effects such as whether the previous OTP is invalidated, rate limits, or what happens to the existing activation state. This is decent but incomplete for a mutation-like 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 a single sentence with the purpose front-loaded, followed by a critical warning and a requirement. There is no fluff, and the structure efficiently conveys the most important information first.

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 core purpose, cost, and prerequisite (id origin). It does not state what the tool returns, but given the simplicity and the analogous request_resend sibling, this is a minor gap. Overall, it is mostly 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 schema already describes the single parameter 'id' with 100% coverage ('Email activation id (from email_request or email_list)'). The description adds no extra meaning beyond implying the id corresponds to an existing email activation. 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 clearly states the specific action: 'Re-open the same email address for another OTP'. It also explicitly names the sibling equivalent (SMS request_resend), which distinguishes it from email_request (new email) and email_cancel. This is a specific verb+resource with clear 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 implies when to use it (when you need another OTP for an existing email activation) by referencing the id source from email_request or email_list and calling it the email equivalent of request_resend. However, it does not explicitly state when not to use it or name alternatives like email_request or email_cancel, leaving some inference to 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?

With no annotations provided, the description carries the full burden and does it well: it warns that the call immediately spends wallet funds, requires an API key, and explains the best-effort replay guard so the agent understands cost and deduplication behavior upfront.

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, front-loaded with purpose and the cost warning, and every sentence contributes either a prerequisite, a hazard, or an idempotency rule. No filler or redundant schema 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 three-parameter tool with no output schema and no annotations, the description covers the essential context: what to do first, what it costs, what auth is needed, and how to avoid duplicate charges or intentionally request a second address. An agent has enough information to call 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?

Even though schema coverage is 100%, the description adds substantial meaning beyond the schema: it explains that domain should come from email_get_domains and, more importantly, clarifies that reusing idempotency_token replays without charging while a different token intentionally orders a second address. This is exactly the kind of semantic nuance an agent needs.

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: "Reserve a temporary email address for OTP verification." It also names the prerequisite sibling (email_get_domains) and hints at the alternate behavior of email_reorder via idempotency, so it is easy to distinguish 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 gives clear context: use email_get_domains first to pick site and domain, and explains how to use idempotency_token for retries vs. ordering a second address. It does not explicitly list when-not-to-use alternatives, but the guidance is specific and 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 provided, the description carries the full burden. It explicitly states 'Does not spend,' signaling a non-destructive read, and notes the API key requirement. However, it does not disclose any other behaviors like response format, rate limits, or potential side effects beyond the minimal non-spending note.

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 with no filler. The purpose is front-loaded, and each sentence adds necessary information: action, prerequisite, and safety. It is an exemplary model of conciseness.

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 with no parameters, the description covers the essential context: what it does, the API key prerequisite, and that it is non-destructive. It does not specify the return value format, but for a balance check, an agent can reasonably infer the outcome. The absence of an output schema makes this slightly less complete, but the description remains 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?

There are zero parameters, so the description has no need to explain them. The baseline for zero-parameter tools is 4, and the description correctly focuses on the authentication requirement, which is a behavioral prerequisite rather than a 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 states a specific verb ('Get'), a clear resource ('wallet balance'), and adds 'current' to clarify scope. It is distinct from all sibling tools, none of which deal with balances, so an agent can immediately recognize 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 description mentions the API key requirement, which is a prerequisite, but does not explicitly state when to use this tool vs alternatives. Since no sibling covers balances, it is implicitly clear, but there is no explicit usage context or exclusion.

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 disclosure burden. It does add a concrete trait by stating 'No API key required,' and 'Get details' conventionally implies a read-only operation. However, it does not disclose whether any other authentication is needed, how unknown slugs are handled, or whether the operation has any side effects.

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

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

The description is two short sentences with zero filler. The core operation is front-loaded, and the 'No API key required' statement earns its place by giving an essential invocation detail.

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 one-parameter read tool with no output schema and no annotations, the description is mostly complete: it identifies the input format and the no-key requirement. The only gaps are explicit return-value details and error behavior, but these are minor for such a simple operation.

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

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

The schema already fully documents the single 'slug' parameter with the same explanation (SEO slug or service code) and examples. The description adds no parameter-level meaning beyond what the schema provides, so the high schema coverage 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 ('Get'), a precise resource ('details for a single service'), and the lookup key format (SEO slug or service code). 'Single service' clearly distinguishes it from list_services and get_service_countries, making its purpose unambiguous.

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

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

The description implies usage: to retrieve details for one service, but it does not explicitly compare against siblings like list_services or get_service_countries, nor does it give conditions for choosing this tool. The 'single service' wording is enough for an agent to infer its niche, but there is no direct when-to-use guidance.

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

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

With no annotations, the description carries the full burden. It discloses the auth requirement ('No API key required'), the filtering behavior ('stock > 0'), and the fields returned. It doesn't mention rate limits, errors, or pagination, but for a simple list endpoint this is substantial 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?

Three concise sentences, each with a distinct purpose: the action and output fields, the auth note, and the follow-up usage. No filler, and the core function 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?

For a single-parameter tool with no output schema and no annotations, the description covers the essential calling contract: what it returns (including specific fields), that no API key is needed, and how to use the result for ordering. Pagination and error behavior are unstated, but those are secondary for this simple list operation.

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

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

Schema coverage is 100% – the schema already documents that slug accepts an SEO slug or service code. The description only echoes this in 'service code/slug' and adds no new parameter-level detail. Baseline 3 is appropriate when the schema already describes the parameter fully.

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 leads with a specific verb and object: 'List in-stock countries for a service', immediately scoping the operation. It adds the filter 'stock > 0' and enumerates returned fields (prices, currency, stock, speed tiers), which distinguishes it from generic siblings like list_countries or get_service.

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 positions the tool as a prerequisite step: 'Use the returned isoCode + service code/slug to order a number.' This gives a clear context for when to call it. However, it does not explicitly name alternatives or state when not to use it, so it stops 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 provided, the description carries the full behavioral burden, and it does a solid job: it discloses the auth requirement ('Requires an API key'), the non-mutating/non-spending nature ('Does not spend'), and the conditional presence of the SMS code ('if received'). This is genuine value 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?

Two short sentences with zero waste; the core purpose is front-loaded and the two behavioral notes ('Requires an API key', 'Does not spend') are each earned additions.

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 single-parameter read tool with no output schema, the description covers purpose, auth, and cost behavior. The only minor gap is the absence of return-format details, but that is a small omission given the tool's 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% and the schema already documents id as 'Activation id (from request_number or list_activations)'. The description adds only marginal context (the 'one activation' phrasing hints at the single id), so the 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?

States a specific verb ('Get') and resource ('status and SMS code for one activation'), and the 'for one activation' phrasing distinguishes it from the sibling list_activations, which returns many. An agent can tell this apart from its siblings without opening the schema.

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

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

The description implies usage context ('Does not spend' signals it is safe to poll without cost, and 'Requires an API key' sets an auth precondition), but it never names alternatives or states explicit when-to-use vs when-not-to-use conditions. Sibling differentiation is left to inference.

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

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

Since annotations are absent, the description carries the burden. It discloses key behavioral aspects: requires API key and does not spend, which is useful. However, it omits details like rate limits or whether it returns only paid vs all activations.

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 that front-loads the main action and includes two crucial behavioral notes, with zero fluff.

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

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

Given the tool's moderate complexity and the absence of output schema, the description covers essential aspects like pagination and auth, but could mention the response format or error conditions. 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%, so the schema already documents each parameter adequately. The description adds no extra semantics beyond what is in the schema, so 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 'List your activations' with specifics on pagination and ordering, distinguishing it from siblings like 'list_services' and 'list_transactions'.

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 (listing activations), but does not explicitly mention when not to use it or recommend alternatives, though siblings are distinct 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, the description carries the full burden of behavioral disclosure. It states that no API key is required and that the operation lists all supported countries, which implies a non-destructive read. However, it does not mention pagination, response envelope, rate limits, or any caveats; for a simple zero-parameter list tool 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 that states the action, scope, returned fields, and auth requirement with no wasted words. It is appropriately sized for the simplicity of the tool and 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 zero-parameter tool with no output schema and no annotations, the description covers the core what, scope, and auth requirement. The main gap is the relationship to the sibling get_service_countries, but the 'all supported countries' phrasing provides enough global context for most agents to use 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 input schema is an empty object with no parameters, so the description cannot add parameter-level meaning. The zero-parameter case calls for the baseline 4; the description's mention of returned fields is informative but not about parameters.

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 a specific verb ('List') and resource ('all supported countries'), and specifies the returned fields (flags and ISO codes). It does not explicitly differentiate itself from the sibling get_service_countries, though 'all supported countries' hints at a global scope. Because the differentiation is only implied rather than stated, it stops short of 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?

There is no guidance about when to choose this tool over alternatives such as get_service_countries or list_services. 'No API key required' is an access note, not a selection criterion, and no exclusions or conditions are provided. This leaves the agent to infer the appropriate context on its own.

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 behavioral disclosure burden. It explicitly states the auth requirement ('No API key required') and the filtering behavior ('all active'), and the 'List' verb implies a read-only operation. It does not mention rate limits or response format, but these are not material for this simple list.

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 only three short sentences, with the core purpose and data contents front-loaded. Every sentence adds useful information and 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?

Given that this is a zero-parameter, read-only listing tool with no output schema, the description is complete: it states the resource, scope, data included, auth requirement, and intended use. An agent has enough information to select and 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 tool takes zero parameters, so the input schema already fully covers invocation. The description adds no parameter details, but none are needed; the baseline of 4 for a parameterless tool 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 action ('List') and resource ('all active SMS verification services') and summarizes what is included ('stock and minimum-price summaries'). It does not explicitly differentiate from sibling tools like get_service, but the 'all active' qualifier helps set scope.

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 a direct use case: 'Use this to discover available services and their slugs/codes.' It also notes that no API key is required. It stops short of saying when to prefer alternatives, but the usage context is clear enough for a zero-parameter listing 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 provided, the description carries the burden of behavioral disclosure, and it does so well: it reveals cursor-based pagination, an API key requirement, and explicitly states the operation does not spend funds. It does not mention rate limits or response details, but the stated traits cover the most important safety and authentication behaviors.

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

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

A single sentence packs the core purpose, transaction types, pagination behavior, auth requirement, and a safety guarantee, with no filler or redundancy. The most important 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?

For a simple read-only list tool with two optional parameters and no output schema, the description provides the essential operational context: what it lists, how pagination works, what credentials are needed, and that it is non-mutating. A description of the expected response shape would push this to a 5, but the current coverage is strong.

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

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

Schema description coverage is 100%, so the schema already fully documents both `limit` and `cursor`. The description's mention of 'cursor-paginated' aligns with the schema but adds little meaning beyond it; the baseline of 3 is appropriate because the schema handles parameter semantics.

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

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

States a specific verb ('List'), a specific resource ('wallet transactions'), and the scope ('recent'), and enumerates the transaction types covered. This clearly distinguishes it from sibling list tools such as list_services and list_activations, which operate on different resources.

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 that this is the tool for viewing recent wallet transactions, and the note 'Does not spend' provides an important exclusion that helps an agent understand it is safe for read-only use. It does not explicitly name alternatives, but the resource scope itself is clear enough given the sibling set.

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 admirably. It discloses the critical side effect (immediate wallet spend), a prerequisite (API key), and the idempotency behavior (identical calls replayed without charging, distinct tokens for new orders). This covers the primary risks an agent needs to know before invoking a purchase 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 compact and front-loaded with the most critical warning (wallet spend). Each sentence earns its place: the purpose, the prerequisite, the retry guard, and the intentional second-order scenario. 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 transactional tool with no output schema, the description covers the action, prerequisites, side effects, and retry semantics. It doesn't describe the response format (e.g., the number returned) or potential error conditions like insufficient balance, but these are not strictly required for a correct call, and the description adequately equips an agent to make the request.

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, but the description adds meaningful context: it tells the agent to source serviceCode from list_services and countryIso from get_service_countries, and it explains the semantics of idempotency_token beyond the schema's basic description. This adds value beyond the raw parameter definitions.

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 ('Reserve a virtual number') and the resource (for SMS verification). It distinguishes this from sibling tools like list_services (which list services) and get_status (which checks status) by implying an order/purchase action. The immediate wallet-spend warning further differentiates it as a transactional tool.

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

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

Explicitly instructs the agent to use list_services / get_service_countries first to select serviceCode and countryIso, establishing clear prerequisites. It also explains the retry guard and how to intentionally order a second number via a distinct idempotency_token. While it doesn't explicitly state when NOT to use it (e.g., use get_balance to check funds), the purpose is clear enough that an agent can infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that an API key is required and that the action is rate-limited per activation. However, it does not mention side effects like cost, response behavior, or failure cases, which would enrich transparency for a mutating action.

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 that deliver the core action, the key limitation, and the authentication requirement with no waste. 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?

For a single-parameter tool with no output schema, this is nearly complete: it states the action, scope, limitation, and auth requirement. It could be more complete by noting what the response signifies or that sending may incur a charge, but nothing essential is missing for 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?

Schema coverage is 100%, and the schema already explains that id is an activation id from request_number or list_activations. The description adds only the 'same number' context, so it does not meaningfully extend parameter understanding 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?

States a specific verb and resource: ask the provider to send another SMS to the same number. This clearly separates it from request_number, which obtains an initial number, and the 'same number' qualifier removes ambiguity about the target.

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: use when a second SMS to the same number is needed, and warns that it is limited per activation. It does not explicitly name alternatives or exclusion cases, so it stops 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.