Wavix

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

No annotations are provided, so the description must carry the burden. It discloses the primary effect but not whether activation is idempotent, what happens if the key is already active, or any permission requirements. This lacks sufficient behavioral detail for a state-changing operation.

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

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

Two short sentences, information-dense and front-loaded. The first sentence states the action; the second clarifies the outcome. No wasted words.

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

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

For a simple one-param tool, the description is adequate but minimal. It doesn't address edge cases (already active, nonexistent id) or prerequisites. While output schema exists, the description could benefit from a note about idempotency or typical use case.

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

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

The single 'id' parameter is fully described in the schema ('API key ID'), so the description adds no additional param semantics. With schema coverage at 100%, the baseline of 3 applies.

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

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

The description clearly states the action ('Activates an API key') and the effect ('can be used for authentication again'). It distinguishes from sibling tools like api_keys_deactivate and api_keys_create by specifying the reactivation purpose.

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

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

The description implies usage for re-enabling a previously deactivated key via the word 'again', but it does not explicitly state when to use this tool vs. alternatives. No exclusions or alternative tools are mentioned, leaving the guidance 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 full burden of behavioral disclosure, but it only states creation and IP restriction capability. It does not mention that the key/secret is typically shown only once, that this is a long-lived write operation, or any authentication/permission requirements.

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

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

The description is two sentences and front-loaded with the primary action. The second sentence about IP restrictions is relevant and earns its place without redundancy.

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

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

An output schema exists and the input schema is fully self-documenting, which lowers the burden on the description. However, the description lacks usage alternatives and critical behavioral notes (e.g., full access when scopes are disabled), leaving it adequate but not fully complete given the tool's complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a minimal paraphrase of permitted_ips and is_restriction ('IP restrictions'), but does not meaningfully extend beyond the schema's already detailed parameter descriptions.

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

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

The description clearly states the tool 'Creates an API key' with a specific verb and resource, distinguishing it from siblings like api_keys_delete or api_keys_list. The additional mention of optional IP restrictions adds scope without confusion.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any mention of prerequisites or post-creation steps. The agent must infer usage solely from the tool name and brief description.

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

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

No annotations are provided, so the description carries the burden. It discloses a key behavioral outcome: after deactivation, authentication fails. However, it does not mention reversibility (via reactivation) or any permission requirements, leaving room for more 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?

One succinct sentence, front-loaded with the action, followed immediately by the consequence. Every word earns its place with no redundancy.

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

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

The tool is simple (single parameter, output schema exists), and the description covers purpose and post-condition. It does not mention reactivation via a sibling, but given low complexity, it is nearly complete.

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

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

Schema coverage is 100% for the single 'id' parameter, and the description adds no additional meaning beyond what the schema's 'API key ID' already provides. Baseline 3 is appropriate.

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

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

The description clearly states the action ('Deactivates an API key') with a specific verb and resource, distinguishing it from siblings like api_keys_activate and api_keys_delete. The consequence ('cannot be used for authentication') adds further clarity.

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 (to disable an API key) and the effect, but does not explicitly contrast with alternatives like api_keys_delete or api_keys_activate. Sibling names provide context, but the description itself lacks explicit when/when-not guidance.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It explicitly states that the action is permanent, which is a critical side-effect warning. However, it does not mention other relevant behaviors such as idempotency, effects on actively used keys, or what happens if the key does not exist.

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

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

The description is extremely concise: two short sentences that deliver the core action and the essential permanence warning. Every word earns its place with no redundancy or filler.

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

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

Given the simplicity of the tool (one parameter, output schema present), the description covers the main purpose and a critical caveat. It could be more complete by mentioning side effects or prerequisites, but for a simple delete, it is largely sufficient.

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 fully documents the single parameter 'id' as 'API key ID.' The description adds no additional meaning or usage details beyond what the schema already provides. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Deletes') and the resource ('an API key'), with an additional warning that the action is permanent. This distinguishes it from sibling tools like api_keys_deactivate, which implies a softer or reversible action.

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

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

The description implies when to use the tool (when you want to permanently delete an API key), but does not explicitly mention alternatives or when not to use it. It does not contrast with api_keys_deactivate, which might be a reasonable alternative for temporary disabling.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states only that the tool returns a list, with no mention of pagination, rate limits, filtering behavior beyond the schema (though the schema does mention label partial match), or confirmation that this is a read-only operation.

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

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

The description is a single sentence of six words, front-loaded with the core action. Every word is necessary and there is 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 simple list tool with one fully documented optional parameter and an output schema, the minimal description is largely sufficient. However, it could have mentioned that the list can be filtered via the label parameter, even though that is in the schema. Overall, the description is adequate given the low complexity.

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

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

The input schema has 100% coverage, with the single optional parameter 'label' already described as 'Label to filter API keys. Partial match supported.' The description adds no extra meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description 'Returns a list of API keys' uses a specific verb (Returns) and resource (list of API keys), clearly distinguishing it from sibling tools like api_keys_activate, api_keys_create, api_keys_deactivate, and api_keys_delete, which are all mutation 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 through its verb: you call this tool when you need to retrieve API keys. However, it provides no explicit guidance on when to use it versus alternatives, nor any exclusions or preconditions, so it falls short of a 4 but goes beyond having no guidance at all.

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 transparently discloses a key behavioral trait: the tool returns a dict with download_url, content_type, status_code, and note rather than the binary PDF, and instructs the agent to fetch the download_url. This adds meaningful context beyond the schema.

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

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

The description is two sentences: first states the purpose, second explains the return format and next step. It is concise, front-loaded, and contains no filler.

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

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

For a simple one-parameter tool with an output schema, the description covers the essential contextual points: what the tool does, what it returns, and what to do with the result. It is slightly incomplete in not explaining parameter semantics or error/note details, but overall sufficient for a tool of this complexity.

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

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

Schema description coverage is 0% and the only parameter (id) is not mentioned in the description. The description does not clarify that id is the invoice identifier, leaving the agent to infer from the tool name. The description fails to add 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 uses a specific verb+resource ("Get a download URL for a billing invoice PDF") and clearly distinguishes this tool from the sibling billing_invoices_list by focusing on downloading a specific invoice's PDF rather than listing invoices.

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

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

The description implies when to use this tool (when you need a download URL for an invoice PDF) but does not explicitly state when not to use it or name alternative tools. The phrase "instead of the binary PDF stream" gives some context but stops short of clear usage guidance.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only mentions pagination, omitting details like default page size, maximum per_page, ordering, authorization scope, or whether only certain invoice states are returned. The output schema exists but is separate from the description.

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, concise sentence with no filler. Every word contributes to the core purpose, and it is front-loaded with the action. This is an appropriate size for such a simple list operation.

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

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

The tool is simple and has an output schema, so the description is minimally adequate. However, it lacks context about the invoice scope (e.g., only unpaid, all invoices) and fails to distinguish from billing_transactions_list, leaving some ambiguity that is not resolved by the sparse description or annotations.

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% with clear descriptions and examples for both page and per_page. The description adds no extra parameter semantics beyond the word 'paginated', which is already implied. Baseline of 3 applies because the schema handles parameter meaning.

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 'Returns a paginated list of financial statements' uses a specific verb and resource, clearly indicating a list operation for billing invoices. It does not explicitly differentiate from siblings like billing_transactions_list or billing_invoices_download, and 'financial statements' is slightly vague, but the tool name clarifies the 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?

No usage guidance is provided. The description does not mention when to use this tool versus billing_transactions_list or billing_invoices_download, nor does it offer any context about filtering, sorting, or prerequisites. An agent would have no reason to prefer this over a sibling.

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 does convey the read-only nature (returns a list) and pagination, but it omits scope (main account vs sub-accounts), pagination behavior (defaults/limits), and what counts as 'financial transactions'. With 7 parameters, this is thin 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?

A single efficient sentence with the verb front-loaded and zero filler. It is appropriately concise, though it leans toward under-specification rather than a balanced description.

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 output schema covers return values and the input schema is thorough, lightening the description's load. However, it lacks usage context, sibling differentiation, and any behavioral detail beyond pagination. It is adequate for a simple list tool but has clear gaps given 7 parameters and no annotations.

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%—all 7 parameters have descriptions, including the rich type enum mapping for all transaction types. The description itself adds no parameter information, but per the baseline rule for high coverage, 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 'Returns a paginated list of financial transactions' uses a specific verb (returns) and clearly identifies the resource (financial transactions) with a notable attribute (paginated). However, it does not distinguish from similar siblings like sub_accounts_transactions_list or billing_invoices_list, which could cause scope confusion.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention billing_invoices_list for invoices, sub_accounts_transactions_list for sub-accounts, or any prerequisites or use cases.

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 behavioral burden. It reveals the `has_provinces_or_states` filter but does not disclose that a specific country must be supplied via the required `country` parameter, nor does it mention the `text_enabled_only` behavior. It also leaves ambiguity whether it returns cities across all matching countries or only for the given country.

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

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

The description is a single, front-loaded sentence with no waste. It immediately states the return type and the key filter, making it easy to scan and understand.

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

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

The description is too brief for full completeness. It creates ambiguity by saying 'for countries' (plural) while the schema requires a single country ID. It also does not mention the optional `text_enabled_only` parameter or provide any guidance relative to sibling tools. Although an output schema exists, the description should clarify the required country scope to avoid misinterpretation.

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 parameters are already well-documented ('Country ID' and 'Indicates whether to return only cities with text-enabled numbers'). The description adds no additional parameter context, 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 the action ('Returns a list of cities') and the specific resource: cities for countries where `has_provinces_or_states` is false. This is a specific verb+resource that distinguishes it from sibling tools like `buy_region_cities_list` or `buy_countries_list`.

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 tool for countries without provinces/states. However, it does not explicitly mention when to use it versus alternatives like `buy_region_cities_list` or `buy_countries_list`, nor does it state exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the burden. 'Returns' implies a read-only operation, but no additional behavioral details are disclosed (e.g., pagination, filtering behavior, or the meaning of 'available'). The description is not misleading but lacks depth beyond the obvious read-only 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?

The description is a single concise sentence: 'Returns a list of countries where phone numbers are available.' It is front-loaded with the action and resource, contains no filler, and every word contributes to meaning.

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

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

For a simple list tool with one optional parameter and an output schema, the description adequately conveys the tool's function. It could mention the relationship to sibling tools (e.g., countries as a prerequisite for regions/cities), but the basic functionality is fully described.

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% because the only parameter 'text_enabled_only' has a description in the schema. The tool description itself does not mention this parameter, but since the schema fully explains it, baseline 3 is appropriate.

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

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

The description clearly states the tool returns a list of countries where phone numbers are available. The verb 'Returns' and resource 'countries' specify the exact purpose, and it distinguishes itself from siblings like buy_cities_list and buy_regions_list by focusing on countries.

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

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

The description implies usage when a list of available countries is needed, but provides no explicit guidance on when to use this tool versus alternatives like buy_cities_list or buy_regions_list. There is no mention of exclusions or prerequisites, so guidance is minimal.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that the result is paginated, but does not explicitly say it's a read-only operation, what side effects (if any) exist, or any constraints beyond the parameters. No contradiction with annotations since none are provided.

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, clear sentence that does not waste words. It is front-loaded with the core action and resource, making it easy to parse.

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

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

The tool is a simple list operation with a complete input schema and an existing output schema, so the description doesn't need to explain return values. The main gap is lack of usage guidance, but given the simple nature and structured fields, the description is mostly sufficient.

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

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

The input schema has 100% parameter descriptions, so the schema already covers all parameter semantics. The description adds no additional meaning about parameters beyond mentioning pagination, which is already implicit in the page/per_page fields.

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

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

The description clearly states the tool returns a paginated list of phone numbers available for purchase. This distinguishes it from sibling tools like buy_cities_list or my_numbers_list by explicitly mentioning the purchase context and the listing action.

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

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

The usage is implied by the name and description, but there is no explicit guidance on when to use this tool versus alternatives like my_numbers_list (existing numbers) or buy_countries_list (countries for purchasing). No exclusions or alternative tools are mentioned.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses the conditional behavior and return type, but does not mention side effects, error handling, or authentication. For a simple read-only list operation, this is acceptable but minimal.

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

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

The description is a single sentence that front-loads the action and resource, with no filler or redundant 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 simple list tool with an output schema, the description covers the core operation and the key condition. It could mention text_enabled_only or error scenarios, but these are adequately handled by the schema and output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds relational context by tying country and region together and explaining the condition on has_provinces_or_states, which goes beyond the schema's individual field descriptions.

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

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

The description uses a specific verb ('Returns') and resource ('a list of cities in the specified region') and adds a decisive condition ('for countries where has_provinces_or_states is true'). This clearly distinguishes it from sibling tools like buy_cities_list and buy_regions_list.

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

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

The description clearly implies when to use this tool: only for countries with provinces or states. However, it does not explicitly name alternative tools or state when not to use it, though the condition effectively serves this purpose.

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 transparency burden. It discloses a key behavioral condition (only returns regions for countries where has_provinces_or_states is true) and states it returns a list. It does not cover edge cases like invalid country IDs, empty results, or pagination, but for a simple read-only list tool this is acceptable yet not exhaustive.

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 and key condition without redundant wording. Every word contributes directly to understanding the tool's purpose.

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

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

With an output schema present and only two parameters, the description covers the essential scope: regions, the country filter, and the conditional availability based on has_provinces_or_states. It could have briefly pointed to buy_countries_list to identify eligible countries, but overall it is sufficient 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%: both 'country' and 'text_enabled_only' are already well-described in the input schema. The tool description adds no additional parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns a list of regions (states or provinces), with a specific condition (only for countries where has_provinces_or_states is true). The verb 'Returns' and resource 'regions' make the purpose concrete, and the condition helps differentiate from related list tools like buy_countries_list or buy_cities_list, though no sibling tool is explicitly named.

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

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

The description implies the tool should be used only for countries that have provinces or states, and the required 'country' parameter reinforces that. However, it does not explicitly mention alternatives or provide when-not-to-use guidance relative to sibling tools such as buy_region_cities_list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core action and optional streaming, but omits side effects, error conditions, call lifecycle behavior, and the existence of recording/transcription options. This is a significant gap for a call-routing 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?

The description is two sentences with the primary action front-loaded and the optional behavior in the second sentence. Every word is informative, and there is no filler or redundancy.

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

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

Given the tool's moderate complexity (6 parameters, streaming modes, recording/transcription toggles), the description is underspecified. It fails to explain when streaming is appropriate, how parameters interact, or the expected preconditions (e.g., call must be incoming and unanswered). The output schema exists but does not compensate for the lack of invocation context.

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 contains detailed descriptions for all parameters, including enum-specific behavior for stream_type and stream_channel. The tool description adds no parameter-specific meaning beyond the generic mention of 'media streaming', so it provides minimal value over the schema.

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

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

The description uses the specific verb 'Answers' and identifies the resource as 'inbound call', clearly distinguishing it from sibling tools like call_control_create or call_control_audio_play. It also mentions the optional streaming behavior, making the tool's scope 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?

No guidance is provided on when to use this tool versus alternatives such as call_control_streams_create or call_control_audio_play. There is no mention of prerequisites, call state requirements, or exclusions, leaving the agent to infer usage only from the tool's name and purpose.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action without mentioning prerequisites (e.g., active call required), side effects (e.g., what happens if audio already playing), or failure behavior. This is a significant gap for a tool that plays media in a call.

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 zero wasted words. It is front-loaded and appropriately sized for a simple tool.

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 full schema coverage, the description lacks crucial context such as prerequisites (active call), behavior on invalid input, or interaction with existing audio streams. With no annotations, the description should provide more behavioral completeness for a 2-parameter tool.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (uuid and audio_file). The description adds no extra semantic meaning beyond what the schema provides, 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 'Plays audio in an active call' uses a specific verb (plays), identifies the resource (audio), and specifies the context (active call). It clearly distinguishes from sibling tools like call_control_audio_stop by stating the action directly.

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

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

The phrase 'in an active call' implies the tool should be used when an active call exists, but there is no explicit guidance on when to use this vs. call_control_audio_stop or other call control tools. Usage is implied rather than 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action without mentioning edge cases (e.g., what happens if no audio is playing), idempotency, error conditions, or prerequisites.

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?

One concise sentence with no wasted words. It is front-loaded and every word earns its place, making it easy to parse quickly.

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, the description covers the core action. However, with no annotations and minimal context about when to use it or expected behavior, it is only minimally complete for an AI agent to invoke correctly.

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

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

The schema already describes the single parameter (uuid: 'Call ID.') with 100% coverage. The description adds no extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('stops') and resource ('audio playback in an active call'), clearly distinguishing it from sibling tools like call_control_audio_play. It tells the agent exactly what the tool does.

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

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

The description implies usage during an active call where audio is playing, but does not explicitly state when to use it versus alternatives like call_control_audio_play or other call_control tools. It provides no exclusions or alternative recommendations.

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 only states the basic action, omitting details about call blocking, timeout handling, max attempts, termination behavior, or side effects on the call.

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 clear sentence with no unnecessary words, front-loading the primary action. It is appropriately concise for stating the tool's core purpose.

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

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

Though the schema documents all parameters and an output schema exists, the description lacks contextual completeness for a complex call-control tool. It does not explain when to use it in a call flow, what happens after collection, or how it interacts with other call actions.

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

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

Schema coverage is 100%, with each parameter described in the schema. The description adds no parameter semantics beyond 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 uses a specific verb ('Collects') and resource ('DTMF input'), and clarifies the context ('in an active call'). This clearly distinguishes it from sibling call control tools like call_control_audio_play or call_control_answer.

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 during an active call when DTMF input is needed, but provides no explicit guidance on when to use this tool vs alternatives, no prerequisites, and no exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Starts an outbound call' and fails to mention side effects, async callback behavior, billing implications, permissions, or call lifecycle, which are significant for a call-control mutation.

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

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

The description is a single, well-formed sentence that immediately conveys the core action. It contains no filler or redundant content, making it highly concise and front-loaded.

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

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

Despite having an output schema and a rich input schema, the tool is a complex call-control action with asynchronous behavior (callback_url), optional recording, and voicemail detection. The description does not explain call lifecycle, prerequisites, or operational context, leaving significant gaps beyond what the schema covers.

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 documents all parameters. The description adds no parameter-level meaning, but the schema's per-field descriptions are detailed, 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 states a specific verb and resource: 'Starts an outbound call.' This clearly distinguishes the tool from siblings like call_control_answer, call_control_get, and call_control_update, and leaves no ambiguity about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. It only implies use for initiating outbound calls, without contrasting with call_control_answer or other call-control tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. 'Ends an active call' does not explain whether the action is irreversible, what side effects occur (e.g., on recordings or billing), or how errors are handled.

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, concise sentence that front-loads the verb and object. There is no filler, repetition, or unnecessary 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?

The tool is simple with one parameter and an output schema, so the description covers the core action. However, it lacks important context such as preconditions and side effects, making it only minimally complete rather than robust.

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 'uuid' parameter as 'Call ID' with 100% coverage. The description adds no new parameter semantics beyond referring to an active call, so it meets the baseline for full schema coverage.

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

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

The description 'Ends an active call' uses a specific verb and resource, making the tool's purpose immediately clear. It distinguishes itself from sibling call-control tools like call_control_answer or call_control_update, which have different actions.

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 usage guidance is provided. The description does not state when to use this tool versus alternatives, nor does it mention prerequisites or conditions like the call needing to be active.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Returns a call' only implies a read operation and adds no information about error handling, permissions, or output specifics. It provides minimal value beyond the tool name.

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

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

The description is a single short sentence, making it concise without wordiness. However, it is under-specifying, lacking useful details that would help an agent, so it is not as effective as a more informative but still concise description.

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 getter with an output schema, 'Returns a call' provides minimum viable information. However, it misses context such as identifying the call by UUID (though present in schema) and could benefit from a note distinguishing it from call_control_list.

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%, with the uuid parameter described as 'Call ID.' The description does not add any parameter information beyond the schema, so the baseline score of 3 applies.

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

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

The description 'Returns a call' clearly states the verb (returns) and resource (a call), indicating this tool retrieves a single call. However, it does not explicitly distinguish from sibling tools like call_control_list, which also relates to calls, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for retrieving a single call by UUID, nor does it reference call_control_list for multiple calls or any other exclusions.

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

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

With no annotations provided, the description carries the full burden. It only states the return type and basic scope but doesn't disclose pagination, ordering, data freshness, or any caveats. As a read operation, it likely has no side effects, but the description doesn't explicitly confirm this.

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

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

A single sentence with no extraneous words. It is appropriately minimal for a simple list operation.

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

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

The tool is simple with no parameters and has an output schema, so the description doesn't need to cover much. It states the basic purpose but leaves questions about what constitutes an 'active call' and possible pagination unanswered, making it adequate but not rich.

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

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

The tool has zero parameters, so the description doesn't need to elaborate on parameter semantics. The baseline is 4 for no-parameter tools, and the description is consistent.

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

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

The description clearly states the tool returns a list of active calls, using a specific verb and resource. It distinguishes from sibling tools like call_control_get by focusing on listing active calls rather than retrieving a single call, though it doesn't explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any use cases, conditions, or distinctions from other call control tools.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. 'Starts call media streaming' implies a state change but does not mention that it creates a stream resource, requires an existing call, or has any side effects or failure modes. This is minimal transparency for a mutation-like operation.

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

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

The description is a single, brief sentence, which is concise and front-loaded. However, it is under-specified rather than efficiently informative; it does not contain enough content to be highly useful, but it is not verbose either.

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

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

Despite having an output schema, the description is incomplete in context. It does not mention that streaming applies to an active call, that a WebSocket URL is required, or describe the oneway/twoway distinction. Given the tool's complexity and the absence of annotations, more context is needed for confident invocation.

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

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

The description adds no parameter-level meaning beyond the schema. Schema coverage is only 50%, so the description should compensate but does not. It fails to explain how uuid, stream_url, stream_type, and stream_channel relate to the streaming action, leaving the agent to rely solely on the schema's descriptions.

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

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

The description 'Starts call media streaming' uses a specific verb ('Starts') and resource ('call media streaming'), clearly distinguishing it from sibling tools like call_control_streams_delete and call_control_audio_play. It accurately and succinctly states the tool's purpose.

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

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

The description provides no guidance on when to use this tool, prerequisites (e.g., an active call), or how it compares to alternatives like call_control_audio_play. It is a single statement with no contextual framing, leaving the agent to infer usage from the name and schema.

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

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

No annotations are provided, so the description must disclose behavioral traits, but it only states the primary effect. It doesn't mention whether the operation is reversible, whether it requires an active stream, or any error conditions. This is minimal for a destructive operation.

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

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

The description is a single, concise sentence with no wasted words. It is appropriately sized for a simple operation, though it could benefit from additional context without becoming verbose.

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

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

While an output schema exists (so return values aren't needed), the description is missing critical context such as whether the stream must exist, idempotency behavior, or related resources. The operation is simple, but the sparse description leaves gaps for an agent.

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

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

The input schema has 100% coverage with clear descriptions for both parameters ('Call ID.' and 'Stream ID.'). The description adds no parameter-specific meaning, 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 'Stops call media streaming' clearly specifies the action (stops) and the resource (call media streaming), distinguishing it from the sibling 'call_control_streams_create' which starts streaming. It avoids tautology by explaining the effect rather than just repeating the 'delete' in the name.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any preconditions or exclusions. It simply states the action, leaving the agent to infer usage from the name.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It proactively states a key constraint ('Only the `tag` field can be modified') and a precondition ('active call'), which goes beyond what the schema reveals. It does not disclose error behavior or permissions, but for a simple update tool this is a reasonable level of 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 extremely concise and front-loaded, using only two short sentences. Every word contributes meaning, with no filler or redundant information. It clearly states the primary action and the critical limitation.

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

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

Given the tool's simplicity (2 required parameters, no nested objects) and the presence of an output schema, the description is largely complete. It covers the essential purpose and the main behavioral constraint. It omits potential error modes, but for a trivial update operation, this is acceptable and the output schema handles return value expectations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying that the `tag` parameter is the sole field that can be updated and that `uuid` refers to an active call. This supplements the somewhat vague schema descriptions ('Call metadata', 'Call ID') with practical usage 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 clearly states the tool's function with a specific verb ('Updates'), identifies the resource ('an active call'), and differentiates it from sibling tools by noting the only modifiable field ('Only the `tag` field can be modified'). This distinguishes it from other call_control_* tools like answer, create, or delete.

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

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

The description provides clear context for when to use the tool (on active calls) and implicitly implies that it is for updating a call's tag. However, it does not explicitly mention when not to use it or name alternative tools, though the sibling list makes the distinction obvious.

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

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

With no annotations, the description carries full burden. It only states 'deletes' without disclosing irreversibility, permissions, or side effects, which are critical for a destructive operation.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It conveys the core action efficiently.

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

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

The tool is simple with a complete schema and output schema, but the description lacks any note about permanence or consequences of deletion. It is minimally complete but could benefit from explicit behavioral context.

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 'id' parameter is documented. The description adds no additional parameter semantics, so 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?

The description clearly states the specific action (Deletes) and resource (call recording), distinguishing it from sibling tools like call_recording_get and call_recording_list.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or exclusions. The description simply states the action without usage context.

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

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

With no annotations, the description takes on the full burden and transparently discloses that the tool returns a dict with download_url, content_type, status_code, and note instead of the binary audio, and instructs to fetch download_url to obtain the MP3. It provides useful behavioral context beyond the schema.

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

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

Two sentences, no filler, front-loaded with the primary purpose and followed by return details. 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 simple one-parameter read tool with an output schema, the description covers the purpose, return shape, and next step to obtain the audio file. It is complete enough for an agent to select and invoke correctly.

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

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

The only parameter, call_uuid, is not described in the schema (0% coverage). The tool description implies it identifies the call recording, but doesn't explicitly explain its format or provenance. This partially compensates for the schema gap but could be more explicit.

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

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

The description uses a specific verb 'Get' and resource 'call recording audio file' and clarifies it returns a download URL, distinguishing it from sibling tools like call_recording_list and call_recording_delete.

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

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

The description implies the use case: when you need a download URL for a call recording rather than the binary stream. It doesn't explicitly name alternatives or exclusion criteria, but the context is clear enough.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions pagination, but omits whether this is a safe read operation, any permission requirements, default sorting, or how it behaves without filters. This is insufficient for a list tool with multiple optional parameters.

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

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

The description is a single sentence that is direct and free of fluff. It front-loads the core purpose and does not waste words.

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

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

Despite having 8 parameters (all optional) and an output schema, the description fails to clarify the default behavior (e.g., returns all recordings when no filters are applied), ordering, or typical use cases. It is too sparse for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter information. Each parameter already has a clear description in the schema, so the tool description does not need to repeat them.

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 'Returns a paginated list of call recordings' uses a specific verb ('Returns') and clearly identifies the resource ('call recordings') and mode ('list'). It distinguishes itself from sibling tools like call_recording_get and call_recording_delete by emphasizing the list operation.

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

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

No guidance is provided on when to use this tool versus alternatives such as call_recording_get or cdrs_list. There are no exclusions or scenarios described, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool results in POST callbacks for specific events, which is useful behavioral context. However, it does not address potential issues like duplicate webhook URLs, authorization requirements, or idempotency, leaving significant gaps for a creation 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 only two sentences, front-loads the action, and avoids redundancy. Every word earns its place, making it highly concise and well-structured.

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

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

Given the tool has only two parameters, both fully documented in the schema, and an output schema exists to explain return values, the description is nearly complete. It lacks only minor context about prerequisites or edge cases, but the simplicity of the tool makes the description 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 100%, and the schema already provides detailed descriptions for both 'url' and 'event_type', including enum values with explanations. The description adds no additional parameter semantics beyond what is in the schema, 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 uses a specific verb and resource: 'Creates a call webhook.' It also clarifies the purpose by stating that Wavix sends POST callbacks for 'on-call' and 'post-call' events, distinguishing this from sibling tools like call_webhooks_delete and call_webhooks_list.

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

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

The description clearly implies when to use this tool (to set up call event notifications) and is implicitly differentiated from siblings through the verb 'Creates' versus 'Delete' and 'List'. However, it does not explicitly mention when not to use it or alternative approaches, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action without mentioning side effects, irreversibility, required permissions, or response structure. The schema's parameter description hints at stopping callbacks, but that is not in the tool description itself.

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, concise sentence that is front-loaded and easy to parse. While it is efficient, it is over-minimal and could incorporate more context without sacrificing conciseness, so it does not earn a perfect score.

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 deletion tool, the description is underdeveloped. It does not explain what happens upon deletion, whether the operation is idempotent, or what the output schema contains. Although the schema clarifies the parameter meanings, the overall tool contract is incomplete without behavioral context.

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 100% coverage of the single parameter 'event_type' with detailed explanations for each enum value, so the description does not need to add parameter semantics. The description adds no extra meaning beyond the schema, meeting the baseline for high schema coverage.

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

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

The description uses the specific verb 'Deletes' and identifies the resource 'call webhook', making the action clear and distinguishing it from sibling tools like call_webhooks_create and call_webhooks_list. However, it does not elaborate on what a call webhook is or mention the event types affected, which slightly reduces clarity.

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

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

The description provides no guidance on when to use this tool or how it relates to alternatives. There is no mention of prerequisites, exclusions, or when to prefer other webhook tools. The only usage hints come from the parameter descriptions in the schema, which are not part of the tool's prose description.

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

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

No annotations are provided, so the description carries the burden. It states that the tool returns a list and explains the callback events, but it does not disclose additional behavioral traits such as pagination, ordering, authentication requirements, or side effects. It adds some context but not rich behavioral detail.

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

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

The description is two concise sentences. The first sentence front-loads the primary action and resource, and the second adds relevant domain context about callback events without unnecessary detail. Every word earns its place.

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

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

The tool is simple (no parameters, output schema present). The description adequately conveys the tool's purpose and the domain events, making it sufficient for an agent to select and invoke it. It could explicitly mention that the operation is read-only, but that is implied by 'Returns a list'.

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

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

The input schema has zero parameters with 100% schema description coverage, so there are no parameter semantics for the description to clarify. Per the rubric, a baseline of 4 applies for no-parameter tools.

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 ('Returns a list') and the resource ('configured call webhooks'), distinguishing it from sibling create/delete operations. The added context about POST callbacks for 'on-call' and 'post-call' events reinforces what the webhooks are for, making the purpose unambiguous.

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

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

The description clearly implies when to use this tool (when you need to list configured call webhooks), and the sibling names make it distinct from create/delete. However, it does not explicitly state when not to use it or mention alternatives, so it falls short of explicit exclusion 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the action without revealing idempotency, duplicate handling, whether a cart is created if missing, or any other side effects. This is insufficient for a 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 a single, clear sentence with no filler words. It is front-loaded with the action verb and resource, making it easy to parse quickly.

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

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

The tool is simple with one fully documented parameter and an output schema, which lowers the burden. However, the description omits important behavioral context such as whether the operation is additive, how duplicates are handled, or if a cart is implicitly created. It is minimally adequate but not thorough.

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 fully describes the single 'ids' parameter with a list of phone numbers and an example, covering 100% of parameter documentation. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Adds' and the resources 'phone numbers' and 'cart', distinguishing it from sibling tools like cart_remove, cart_get, and cart_checkout. The action is specific and unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention related cart operations or any preconditions, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It explicitly states that activation and monthly fees are deducted from the account balance, which is a significant financial consequence not evident from the tool name or schema. However, it does not cover potential failure modes such as insufficient balance or whether the operation is reversible.

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 highly concise with two sentences: the first states the primary purpose, and the second adds a key consequence. Every word earns its place, and the main action is front-loaded.

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

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

The tool has a simple one-parameter schema and an output schema (as indicated by context signals), so the description does not need to explain return values. It covers the main effect (checkout) and a critical consequence (fee deduction). Missing details like prerequisites or failure handling, but these are less critical given the simplicity and available schema.

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

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

The input schema covers 100% of the parameter documentation, with 'ids' described as 'List of phone numbers to check out from the cart.' The description adds no additional parameter meaning, 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 uses the specific verb phrase 'Checks out the cart', clearly identifying the action of finalizing a purchase. This distinguishes it from sibling tools like cart_add, cart_get, and cart_remove, which handle other cart 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 the tool is used to complete a cart purchase by noting that fees are deducted, but it does not explicitly state when to use it versus alternatives or provide exclusions. It offers context that this step has financial consequences, but 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the cart is returned, which implies a read operation, but it does not mention authentication requirements, error conditions, whether a new cart is created if none exists, or any side effects. This is insufficient for a tool with zero annotation coverage.

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

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

While the description is extremely short, it is redundant with the tool name and does not add value. It is under-specified rather than concise, as it fails to provide any context or detail that an agent would find useful.

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

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

For a zero-parameter getter, the description is minimally complete in stating the action, but it lacks essential context about which cart is returned, when the tool is appropriate to call, and any prerequisites or implications. The presence of an output schema reduces the need to explain return values, but the description still does not provide enough context for correct invocation.

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

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

The tool has zero parameters and the schema coverage is 100%. The description adds no parameter information, but none is needed. A baseline score of 4 is appropriate for a parameterless tool.

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

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

The description 'Returns the cart' is essentially a restatement of the tool name 'cart_get'. It provides no additional specificity about which cart is returned, whose cart, or any contextual qualifiers. While it identifies the action and resource, it does not distinguish itself beyond the name.

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 use this tool versus the sibling tools cart_add, cart_remove, and cart_checkout. An agent would have to infer usage solely from the tool name and sibling context, as the description offers no alternatives or 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 must disclose behavioral traits. 'Removes' implies mutation, but there is no information about idempotency, behavior on invalid or already-removed IDs, permanence of removal, or side effects. This is a significant gap for a 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 a single, direct sentence with zero waste. It efficiently conveys the core action without unnecessary elaboration.

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

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

The tool is low-complexity with one well-documented parameter and an output schema. However, the description lacks behavioral details (e.g., error handling, idempotency) and usage guidance relative to siblings. It is adequate but leaves clear gaps for an agent to understand full implications.

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

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

The input schema fully documents the only parameter 'ids' with a clear description and example, reaching 100% schema coverage. The tool description adds no additional 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 uses a specific verb ('removes'), the resource ('phone numbers'), and the scope ('the cart'), which clearly distinguishes this from sibling tools like cart_add and cart_get. It unambiguously describes the tool's function.

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

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

The description gives no guidance on when to use this tool instead of alternatives like cart_add or cart_checkout. There is no mention of prerequisites, exclusions, or suitable contexts, leaving the agent without explicit usage direction.

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 full responsibility for disclosing behavioral traits. It only states that call details are returned, omitting any information about read-only nature, error handling, or the effect of the show_transcription parameter. This is a significant gap for a tool that could return sensitive data.

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

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

The description is extremely brief and front-loaded, but it is under-specified rather than concise in a beneficial way. One sentence fails to convey essential context, making it similar to a placeholder.

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

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

Given the tool has many sibling tools and no annotations, the description is incomplete. It does not explain that the tool retrieves a single call detail by required uuid, nor does it clarify how it differs from cdrs_list, cdrs_search, or cdrs_transcription_get. The presence of an output schema partially compensates, but the lack of usage context is a clear gap.

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

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

The input schema provides descriptions for both parameters (uuid and show_transcription) with 100% coverage, so baseline is 3. The description adds no additional parameter semantics or relationship between parameters beyond what the schema already provides.

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

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

The description 'Returns call details' uses a verb and resource but is vague; it does not specify that it retrieves a single call by UUID. It lacks differentiation from sibling tools like cdrs_list or cdrs_search, so it is not specific enough to facilitate correct selection.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention use cases, exclusions, or relationship with the many sibling cdrs_* tools, leaving the agent without context for choosing it.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure. It only states 'paginated list' and provides no details on filtering, pagination behavior, default values, or other operational traits. It is nearly tautological with the tool name.

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

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

The description is a single, direct sentence that states the core purpose without wasted words. It is appropriately sized and front-loaded.

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

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

Despite having a detailed parameter schema and an output schema, the description is too minimal for a tool with 10 parameters and several closely related siblings. It fails to mention required parameters, the difference from cdrs_list_all, or typical use cases, leaving the agent without enough context to select or invoke the tool confidently.

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 100% description coverage, with each parameter offering a description, examples, and some defaults. The description adds no parameter-level meaning beyond the word 'list', so it does not enhance what the schema already provides.

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

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

The description clearly states the action ('Returns') and resource ('a paginated list of CDRs'), making the basic purpose unambiguous. However, it does not distinguish this tool from sibling tools such as cdrs_list_all or cdrs_search, which likely have overlapping list functionality.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention that from/to/type are required, nor does it indicate how this tool relates to cdrs_list_all or cdrs_search.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the return format and purpose, but does not mention pagination behavior, data volume expectations, filtering scope, or any rate limits or read-only semantics beyond 'Returns'. This is insufficient for a tool with many parameters and no safety annotations.

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

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

The description is a single, front-loaded sentence that states the essential purpose without wasted words. Every word contributes to conveying what the tool does.

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

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

This is a complex tool with 10 parameters, no output schema, and no annotations. The one-sentence description does not cover important aspects such as how pagination behaves, whether all parameters are honored in bulk export, or any operational constraints. The description is not complete enough for an agent to use this tool confidently.

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 descriptions cover 100% of the parameters with detailed meaning, so the description does not need to add parameter info. The baseline of 3 applies because the schema does the heavy lifting, and the description adds no additional parameter context (e.g., interactions or defaults beyond schema).

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

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

The description uses a specific verb ('Returns') with a clear resource ('CDRs'), output format ('NDJSON'), and use case ('bulk export'). It distinguishes from sibling tools like cdrs_list or cdrs_search by emphasizing the bulk-export aspect, though it does not explicitly name alternatives.

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

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

The phrase 'for bulk export' implies when to use this tool, but no explicit guidance is given about when not to use it or which sibling tools to prefer. There are no exclusions or alternative tool references, so usage 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 full responsibility for behavioral disclosure. It only states the basic action and gives no indication that retranscription may be asynchronous, overwrite existing data, incur costs, or require specific permissions. The presence of webhook_url suggests asynchronous behavior, but this is not mentioned in the description.

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 concise sentence, front-loaded with the core action and free of unnecessary words. It is easily readable and appropriately sized for a simple purpose statement, though it lacks explanatory depth.

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

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

Despite having an output schema and three parameters, the description is minimal and fails to provide critical context about the asynchronous workflow implied by webhook_url, whether the retranscription replaces the existing transcription, or any usage constraints. An agent would not know how the tool integrates with the broader CDR and transcription lifecycle.

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

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

The input schema covers all three parameters with descriptions and examples, achieving 100% coverage. The tool description adds no additional meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states the tool's action: 'Transcribes a recorded call.' It identifies a specific verb and resource. However, it does not distinguish this tool from siblings like cdrs_transcription_get or speech_analytics_retranscribe, and the name's 'cdrs' context is not reinforced in the description.

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 offers no guidance on when to use retranscription versus fetching an existing transcription or using speech analytics retranscription. It does not mention prerequisite conditions, such as the call being recorded or having an existing transcription, nor does it explain when this tool should be preferred over 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 full burden of behavioral disclosure, but it only says 'searches' with no mention of pagination, default disposition (only answered calls when omitted), optional nature of the transcription filter, or output behavior. It does not contradict annotations (none exist), but offers little beyond the bare 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?

The description is a single concise sentence with no fluff, but it is under-specified for a tool with 12 parameters and nested objects. It is not a tautology, but it lacks substance needed to guide an agent; the brevity does not compensate for missing critical scope.

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

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

Given the tool's complexity (12 parameters, nested transcription filter, output schema), the description is incomplete. It fails to convey that transcription filtering is optional and that the tool can serve as a general CDR search with date and call-type filters. The rich schema covers parameters, but the description lacks the contextual glue needed to understand the tool's full role.

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 83%, with detailed descriptions for most parameters including the nested transcription filter. The top-level description adds no parameter-specific information beyond the vague 'keywords or phrases', so the baseline of 3 applies without further value from the 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 states a clear action ('searches') and a resource ('call transcriptions'), but it mischaracterizes the tool's scope: cdrs_search is a general CDR search with an optional transcription filter, not purely a transcription search. It also omits date-range filtering, pagination, and other filter capabilities, and does not differentiate it from sibling tools like cdrs_list_all or cdrs_transcription_get.

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

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

The description provides no guidance on when to use this tool versus alternatives such as cdrs_list_all or cdrs_transcription_get, and no context about required parameters or typical use cases. The only clue is the name, which is insufficient.

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 only states the basic retrieval action and adds no behavioral context like authentication requirements, error behavior, or output format, leaving the agent without deeper expectations.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple retrieval tool.

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

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

The tool is simple with one documented parameter and an output schema, so the minimal description is almost adequate. However, the lack of any behavioral or usage context makes it only minimally viable rather than fully complete.

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

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

Schema description coverage is 100% for the single parameter 'uuid' (described as 'Call ID'). The description adds no additional parameter semantics, 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 'Returns a recorded call transcription' uses a specific verb and resource, clearly indicating the tool's function. It is reasonably distinct from sibling tools like cdrs_get or speech_analytics_get, though it does not explicitly call out differences.

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

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

No guidance is provided on when to use this tool versus alternatives such as cdrs_retranscribe or speech_analytics_get. The description simply states the action without any context for choosing it.

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

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

With no annotations provided, the description should disclose behavioral traits, but it only states the action. It doesn't mention side effects, required permissions, what happens with optional parameters, rate limits, or any caveats. This is a significant gap for a creation 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, 'Creates a short link.', with zero wasted words. It is maximally concise while still conveying the core purpose.

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

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

The tool has five parameters and an output schema, yet the description provides minimal context. The schema covers parameter meanings and the output schema presumably covers return values, making the description minimally adequate. However, the lack of usage guidance and behavioral context keeps it from being complete.

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

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

The input schema provides detailed descriptions and examples for all five parameters, achieving 100% coverage. The description adds nothing beyond the schema, but the schema itself fully documents the parameters, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Creates') and the resource ('a short link'). This distinguishes it from sibling tools like link_shortener_metrics_list, which focuses on metrics rather than creation.

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

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

No guidance is provided on when to use this tool or what alternatives exist. The description is just a statement of function without any context or exclusions, so there is no direction for tool selection.

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

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

With no annotations provided, the description carries the full burden of disclosure. It only says 'Returns short link metrics' which adds minimal behavioral context; it does not mention pagination, required date range, filtering, authentication needs, or the nature of the metrics (aggregate vs. raw).

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

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

The description is extremely concise (one sentence), but it is under-specified. It is not verbose, yet it lacks structure such as separating the main action from details. The single sentence is efficient but does not add meaningful information beyond the tool name.

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 6 parameters (2 required) and no annotations, this description is inadequate. It does not explain the intended use case, required date range, pagination behavior, or what 'short link metrics' means. The output schema exists, but the description does not provide enough context to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself does not add parameter meanings, but the input schema thoroughly documents each field including examples and descriptions, so the agent can understand the parameters without additional explanation.

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

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

The description clearly states the tool returns short link metrics, which is a specific verb and resource. It does not explicitly distinguish from siblings, but the name and description are unambiguous enough that it's not confusing with other tools like link_shortener_create.

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

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

No guidance is provided on when to use this tool versus alternatives, no exclusions, no context about required parameters or scenarios. The description simply states what it returns without any usage direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action ('releases phone numbers back to stock') but does not mention whether the operation is permanent, if there are prerequisites (e.g., ownership, not in use), or any side effects (e.g., affecting active calls or billing). This is a significant gap for a destructive operation.

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

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

The description is a single, concise sentence that front-loads the core action. It contains no fluff or redundant information, earning a perfect score for structure.

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

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

For a simple delete/release tool, the description is minimally adequate, but it lacks important context such as reversibility or validation behavior. The presence of an output schema and complete parameter descriptions offset some gaps, but because no annotations exist, the description alone does not fully cover the behavioral context expected for a destructive 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 description coverage is 100%, with both 'ids' and 'dids' having clear descriptions in the input schema. The tool description adds no parameter-specific meaning beyond what the schema already provides. A baseline score of 3 is appropriate because the schema already 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?

The description uses the specific verb 'releases' with a clear resource ('phone numbers') and context ('back to stock'), making it obvious what the tool does. It also distinguishes from sibling tools like my_numbers_update (changes settings) and my_numbers_list (lists numbers).

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 its use case through the verb 'releases' but does not explicitly state when to choose this tool over alternatives or provide exclusions. For example, it does not say 'Use this only when you want to permanently return numbers' or contrast with my_numbers_update. Guidance is implied 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, the description carries the full burden of behavioral disclosure. It only states that routing is updated, without revealing whether updates replace existing destinations, whether SMS relay URL is affected, or any side effects. The mutation is implied but not elaborated.

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 no wasted words. It is concise and front-loaded, but the brevity also omits useful context that could be structured or expanded.

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

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

Even though an output schema exists, the description is under-specified for a mutation tool with three required parameters. It does not address whether this is an additive or replacing update, the relationship between destinations and sms_relay_url, or any edge-case behavior. The agent would need to inspect the schema deeply to understand semantics.

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 parameter descriptions are detailed (e.g., destination, priority, transport enum), so the schema does the heavy lifting. The description adds no extra meaning about how parameters interrelate or their combined effect, so the baseline 3 is appropriate.

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

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

The description uses a specific verb 'Updates' and a specific resource 'inbound call routing for phone numbers,' clearly conveying the tool's scope. It distinguishes itself from sibling tools like my_numbers_sms_update (SMS routing) and my_numbers_update (general number settings), though it does not name them explicitly.

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

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

No guidance is provided on when to use this tool versus alternatives, nor does it mention prerequisites, exclusions, or the relationship to related updates. The description only states the action without context, leaving the agent to infer appropriate usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The phrase 'Returns a phone number' implies a read-only operation but does not explicitly state the absence of side effects, permission requirements, or error behavior. For a get tool, this is a minimal disclosure but not rich enough for an agent to understand all behavioral implications.

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

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

The description is a single sentence of four words, which is extremely concise and front-loaded. However, it is under-specified, providing minimal information beyond the tool name. While not verbose, it does not meaningfully expand on the purpose, so a middle score is appropriate.

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 tool with one parameter and an output schema, a brief description might suffice. However, the description lacks context about the domain (e.g., what a 'phone number' is in this system), behavior on missing IDs, and relationships to sibling tools. Given the presence of an output schema, the return structure is covered, but other contextual gaps remain.

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

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

The input schema provides a description for the `id` parameter ('Phone number ID.'), giving 100% schema coverage. The description adds no additional meaning beyond what the schema already states, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Returns') and identifies the resource ('a phone number'), clearly stating the tool's core function. However, it does not explicitly differentiate from the sibling tool `my_numbers_list`, which also deals with phone numbers, so the purpose is clear but lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives such as `my_numbers_list` or `my_numbers_update`. There is no mention of prerequisites, use cases, or when not to use this tool, leaving the agent to infer usage from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that results are paginated with a default limit of 25 records per page, which is actionable behavioral information. It does not describe ordering, filtering behavior, or explicitly label it as read-only, but for a list operation this is reasonably sufficient.

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

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

Two sentences, front-loaded with the primary purpose, followed by behavior and navigation instructions. No redundant or unnecessary words.

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

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

Given the tool has six optional parameters and an output schema, the description provides the essential context (list, pagination, default limit) and does not need to explain return values thanks to the output schema. It could be more explicit about available filters, but the schema fills that gap. Overall, it is sufficiently complete for an agent to understand and 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 schema covers 100% of parameters, so the baseline is 3. The description adds value by specifying the default page size (25) and that `page` and `per_page` are used for navigation, which goes beyond the schema's simple type descriptions. However, it does not comment on the filtering parameters (label, search, city_id, label_present), leaving that to 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 'Returns a paginated list of phone numbers on the account', which clearly identifies the verb (returns), the resource (phone numbers), and scope (on the account). This distinguishes it from sibling tools like buy_numbers_list (which is for purchasing) and my_numbers_get (which retrieves a single number).

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 usage context by stating it lists account numbers and how to navigate pagination with `page` and `per_page`. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, leaving the differentiation to inference from the name.

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

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

With no annotations, the description carries the full burden. It discloses file size, format, and security constraints, which are non-obvious requirements. However, it does not describe the upload behavior beyond the action itself, such as whether it replaces existing documents or triggers downstream processes.

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 front-loaded with the main verb and resource. The bullet-point requirements are structured for easy scanning. No redundant or excessive text.

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

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

The description covers the core action and essential file constraints, but lacks usage guidelines and post-upload behavior. Given the presence of an output schema and complete parameter descriptions, it is mostly sufficient, but could be more helpful with a note on when to use it.

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

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

The schema already documents all three parameters with descriptions, including enum values for doc_id. The description adds value by specifying allowed formats, size limits, and security restrictions for the doc_attachment parameter, which are not in the schema. This enriches the parameter semantics beyond the baseline.

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

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

The description clearly states a specific action (uploads a document) and its scope (for one or more phone numbers). It includes detailed file requirements that further specify what the tool does. Although it doesn't explicitly differentiate from sibling upload tools, the resource (phone numbers) is distinct and evident from the name and description.

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 on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only lists file format constraints, not usage context. No sibling alternatives are mentioned.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states the effect (enable/disable SMS) without mentioning side effects, permissions, reversibility, or response behavior. For a mutation tool, this is insufficient.

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, clear sentence with no filler, front-loading the action and target. It is appropriately sized for a simple toggle operation.

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

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

The tool is simple, and the schema covers parameters, with an output schema present. However, the description lacks usage context and does not mention any constraints or side effects. Given the absence of annotations, it is minimally complete but leaves gaps for a mutation 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 provides 100% coverage for both parameters (id and sms_enabled), including descriptions and examples. The tool description adds no additional 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 uses a specific verb phrase 'Enables or disables' and clearly identifies the resource ('inbound SMS support for a phone number'). This distinguishes it from sibling tools like my_numbers_update and my_numbers_destinations_update, which manage other number settings.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any preconditions, exclusions, or that this is the tool to toggle SMS specifically. The only implied context is from the tool name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions 'Updates a phone number' without explaining partial vs. full update semantics, idempotency, or effects on existing settings. The schema describes parameter details, but the description itself adds no behavioral context.

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

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

The description is extremely concise at four words, single sentence, and front-loaded. It wastes no words, but its brevity borders on under-specification, which is captured in other dimensions.

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 rich schema and an output schema, the description is too minimal for a mutation tool. It lacks any information about when to use it, how it differs from other numeric update tools, or behavioral nuances that would help an agent invoke it correctly. Even with the schema, this is insufficient.

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

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

Schema coverage is 100% with detailed descriptions and examples for all six parameters. The tool description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states 'Updates a phone number,' providing a specific verb and resource. However, it does not distinguish itself from sibling tools like my_numbers_sms_update or my_numbers_destinations_update, which also modify phone number settings.

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 on when to use this tool versus the more targeted my_numbers_sms_update or my_numbers_destinations_update. The description offers no context about which fields are appropriate or exclusions, so an agent cannot know when to choose this tool.

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