Widely

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), the description adds meaningful behavior: the message lands in a human-readable chat, no automated assistant replies, and 'any connected account can send it' warns that the sending identity is not constrained. It still does not say what happens afterward (ticket, confirmation, response channel).

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

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

Three short sentences, front-loaded with the core action and no filler. The closing sentence is slightly clipped ('text is what is needed...') but still carries information, so nothing is wasted.

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

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

For a single-parameter write tool with no output schema and annotations already covering the safety profile, the description covers the action, the expectation of a human respondent, and what to put in the parameter. Only the post-submission behavior (confirmation, follow-up) is left unstated.

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

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

Schema description coverage is 0%, so the schema gives no help on 'text'. The description compensates by specifying what the text should contain ('what is needed and what was already tried'), which is real guidance an agent could not get from the schema alone.

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

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

The first sentence gives a specific verb and resource ('Writes a message into this user's Support chat for a person to read'), which separates it from the read-only sibling read_support and from the generic send_message by naming the Support channel. It also rules out the help-search path by stating Support's own assistant does not answer, but it never names a sibling tool outright, so an agent must infer the routing.

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?

Usage is implied rather than stated: the message is directed 'for a person to read', which signals escalation to human support, and 'text is what is needed and what was already tried' hints at the situation in which to call it. No explicit when-not conditions or named alternatives (search_help, read_support, request_speak) are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description's only extra claim, 'the rate depends on the destination,' is essentially tautological and adds no behavioral context such as whether rates are current, cached, tax-inclusive, or account-specific.

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

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

Two short sentences with the core purpose front-loaded, but the second sentence restates what the first already implies, so it spends words without adding information.

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

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

For a tool with three optional parameters, no output schema, and no annotations describing return behavior, the description is under-specified: it doesn't say what a result looks like, how the optional filters combine, or how it differs from quote_call.

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 description says nothing about country, destination, or number_type. It hints that a 'destination country or number' is involved, but never explains the precedence between country and destination, what number_type values mean, or what happens when all three optional parameters are omitted.

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

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

States a specific verb and resource: returns the per-minute rate for a destination, scoped to this account. However, it never distinguishes itself from close siblings like quote_call, get_data_rate, or get_did_rate, so the agent must guess which rate tool applies.

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 versus quote_call (a quote for an actual call) or the other rate tools, and no mention of prerequisites or when the result would be stale. Usage is left entirely 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the eligibility constraint ('Business plan') and scope ('in-progress conversation'), but does not disclose side effects such as what hangup terminates or that transfer is irreversible.

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, purpose front-loaded, no wasted wording. The 'Business plan.' fragment is abrupt but still carries eligibility information rather than padding.

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

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

For a destructive control tool with no output schema, the description covers the action set and plan requirement, and annotations cover safety. The key gap is the undocumented destination parameter and the lack of any note on call state transitions or failure behavior.

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

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

Schema description coverage is 0%, so the description carries the full burden. It enumerates the action values (hold/resume/hangup/transfer) which maps to the enum, but never explains call_id or the destination parameter, nor that destination is effectively required for the 'transfer' action.

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

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

The description names a clear verb set (holds, resumes, hangs up, transfers) applied to a specific resource (an in-progress conversation on this seat). This makes it easy to distinguish from read siblings like get_call and search_calls, though it never explicitly contrasts them.

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

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

Usage context is only implied: the tool operates on an already 'in-progress' call and is gated by 'Business plan'. There is no explicit when-to-use vs alternatives or exclusion guidance, so the agent must infer that request_call/get_call are the non-control siblings.

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

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

Annotations cover read-only, idempotent, and non-destructive behavior. The description adds useful scope details: it discloses what the response does not include (customer name, refund), which prevents an agent from expecting those. It does not, however, mention rate limits or authentication requirements beyond 'No sign-in'.

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 core purpose. It uses four short sentences with no wasted words. Some minor redundancy exists, but it remains efficient.

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

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

For a read-only tool with no parameters and no output schema, the description adequately covers what the tool does, what it returns, and what it excludes. It could mention error cases or limits, but it is largely complete for the given 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?

With zero parameters, the baseline is 4. The description appropriately focuses on the return content rather than parameters, which is the correct emphasis for a no-param 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 states a specific resource and the exact information returned: the in-app deletion path and the confirmation word. It distinguishes itself from siblings like get_account (account data) and esim_install_steps (eSIM steps) by focusing on a procedure.

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

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

The description implies this is for obtaining deletion instructions, but it does not explicitly state when to use this tool vs. ask_support or other help tools. Usage is inferable from the purpose, but no alternatives or conditions 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: the APN can be null when the profile has none, and no authentication is required — neither of which appears in the annotations.

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

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

Three short sentences, front-loaded with the two return values and immediately followed by the null edge case and the auth note. 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?

With no output schema, the description must carry the return contract, and it does — install path, APN, and the null case. The only gap is guidance on how this relates to the other eSIM-related tools.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing about arguments for the description to clarify or omit.

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

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

States a specific verb and resource — returns the eSIM install path and APN — which is clearly distinct from siblings like quote_esim or get_esim_connection_check. It does not name an alternative, but the purpose itself is 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?

There is no indication of when to use this tool versus quote_esim, get_esim_connection_check, or run_esim_connection_check. 'No sign-in' hints at accessibility but gives no selection criteria 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact beyond the annotations: an empty list means no matching charge, which tells the agent to treat emptiness as 'no match' rather than an error. It still omits pagination, result caps, and how results are derived.

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: the purpose is front-loaded and the empty-result edge case follows second. Nothing is padded or redundant.

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

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

For a one-parameter, read-only tool with no output schema, the description covers purpose and the empty-result case, which is the minimum viable set. It leaves the central mechanic unexplained, namely how the free-text 'question' is interpreted and what a returned charge record looks like.

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

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

There is one parameter, 'question', with 0% schema description coverage, and the description says nothing about it at all. For a tool literally named 'explain_charges', the agent gets no hint that a natural-language question drives the lookup, nor what happens when it is omitted (the parameter is not required).

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 concrete verb and resource with a scope qualifier: it 'returns charges already on this account, with amounts and labels.' That distinguishes retrospective charge lookup from prospective pricing siblings like quote_call/quote_number. It does not, however, contrast itself with list_wallet_activity or the other wallet/balance readers, so sibling differentiation is only partial.

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 explicit when-to-use or when-not-to-use guidance. The phrase 'already on this account' weakly implies the tool is for past charges rather than future quotes, but the agent must infer that from the sibling names, and nothing tells it to prefer this over get_account_balance or list_wallet_activity.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds genuine value beyond that by disclosing the returned data shape (plan, balance, member/eSIM counts, per-seat setups), which matters because no output schema exists.

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, front-loaded with the verb and target, with the returned fields listed compactly. No filler or repetition, though the field list is dense enough that it reads as an enumeration rather than pure prose.

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

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

With no output schema, the description carries the return-value burden and does so by naming the key fields. Annotations cover the safety profile and there are no parameters, so little else is needed; only return format/structuring details are absent.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. The schema is closed (additionalProperties=false) and the description correctly signals a no-argument call.

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

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

States a specific verb-resource pair ('Returns the ... account') and enumerates the exact content returned: plan, wallet balance, member count, live eSIM count, and runnable setups. This is far more specific than a bare name restatement, though it does not explicitly distinguish itself from the overlapping sibling get_account_balance.

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 when-to-use guidance, no prerequisites, and no mention of alternatives despite a very large sibling set containing get_account_balance, list_plans, list_team, and list_esim-related tools. An agent must infer the call context entirely.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered. The description adds genuinely useful non-obvious context: the response is the live headline total and deliberately lacks spendable/reserved breakdown, which prevents an agent from expecting sub-balances.

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 tight sentences, zero waste, with the core definition front-loaded and the output caveat second. 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?

With no output schema, the description carries the burden of describing the return value, and it does so by naming the headline total and explicitly excluding spendable/reserved fields. Minor omissions (currency, staleness/freshness semantics) keep it short of a 5.

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

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

The tool takes zero parameters, which is the baseline-4 case; there is nothing parameter-wise to explain. The description correctly refrains from inventing parameter semantics.

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

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

States a specific verb and resource: returns the live wallet total for this seat, and clarifies it matches the Home/Wallet headline figure. It does not name or contrast with the closest siblings (list_wallet_activity, list_wallet_refunds, get_usage), so it is clear but not sibling-differentiated.

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?

Usage is implied by 'the same headline as Home and Wallet' – an agent can infer this is the summary-balance call rather than a transaction listing. However, there is no explicit when-to-use guidance, no when-not-to-use, and no mention of the wallet activity/refund alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety behavior is covered structurally. The description adds value by disclosing the shape of what comes back (state flag plus threshold and amount), which matters because there is no output 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?

A single short sentence that front-loads the return semantics with zero filler. Every clause ('whether it is on', 'the threshold and amount') 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 no-parameter getter, the description covers the essentials and compensates for the missing output schema by naming the returned fields. Complete enough to call correctly, though it could note the read/set pairing for full routing confidence.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing extra for the description to document. It correctly implies no inputs are needed.

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

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

States a specific verb ('Returns') and resource ('auto top-up'), plus the exact fields returned (on/off, threshold, amount), so an agent immediately knows this is a read of top-up configuration. It does not explicitly name the write counterpart set_auto_topup, so it falls short of full 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 verb 'Returns' implies a read-only lookup, which implicitly contrasts with the sibling set_auto_topup, but the description never states when to prefer this tool or that it is the read companion to set_auto_topup. Usage is inferable but not spelled out.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds content the annotations cannot: that the response is the full detail for one call and includes the carrying identity and provider — meaningful because there is no output 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?

A single well-formed sentence with the action front-loaded and no filler. It is efficient, though it is lean enough that a short second clause on ID origin or return shape would not have hurt.

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

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

For a one-parameter read tool whose annotations already carry the full safety profile, this is close to sufficient: it says what comes back and that the call is located by ID. The residual gap is guidance on where the call_id comes from and how it compares to search_calls.

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% for the single parameter, so the description must carry the burden. It names call_id and frames it as the record identifier, but adds no format, source, or validity guidance beyond what the raw schema type already shows.

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

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

States a specific verb and resource ('Returns full detail for one phone call') and scopes it to a single record via call_id, which implicitly separates it from the sibling search_calls. It never names a sibling, so the differentiation is inferred rather than stated.

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?

'Identified by call_id' implies the agent must already hold an ID (e.g. from search_calls) before calling, which is reasonable implied usage. However, there is no explicit when-to-use statement, no exclusion against list-style siblings, and no note on what to do if the ID is unknown.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower; the description adds genuinely useful behavior by disclosing that the ladder starts from data already used this period (a proration/continuation semantic) and that this is the account rate, not the public shelf. It does not mention return shape beyond the volume-points case, but that is a minor gap.

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

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

Three short sentences, front-loaded with what is returned, then the scoping caveat, then the parameter behavior. No filler; every sentence carries 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 two-parameter read-only lookup with no output schema, the description covers what is returned, the scope of the rate, and the effect of omitting gb. Only the shape of the returned ladder points is left implicit, which is a small remaining gap.

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

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

Schema coverage is 100%, so the baseline is 3, but the description earns an extra point by explaining the consequence of omitting gb ('returns the volume points') — something the schema's 'Omit when they have not said' does not state. That is real meaning added beyond the structured field.

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

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

States a specific verb and resource — returns the customer's pay-as-you-go data ladder — and draws a real conceptual boundary against the 'public shelf' rate, which is the distinction an agent needs to avoid confusing it with the quote_* / get_did_rate siblings. It stops short of naming an actual sibling tool, so it is clear but not fully differentiated.

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?

Usage is implied: fetch this when you need the account-specific rate rather than a public quote. The description supplies the gb-omission rule, which is a calling condition, but it never states when to prefer this over quote_number/quote_esim/get_did_rate, nor any prerequisites. Minimum-viable 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?

Annotations already declare readOnly, idempotent, non-destructive and openWorldHint=false, so the safety profile is covered. The description adds two useful facts beyond the annotations: the price is 'indicative' (an estimate, not a firm quote) and is derived from 'this account's' rate checker, making it account-specific. It still says nothing about currency, billing cadence, or failure modes.

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 front-loaded sentence with no filler or repetition. It is efficiently sized, though it leans so terse that it omits the parameter detail it could have used its budget for.

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

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

For a simple read-only two-parameter tool with annotations covering safety and no output schema, the purpose statement is broadly sufficient. The gaps are the undocumented number_type input and the lack of any hint about the shape or currency of the returned price.

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 description only implicitly covers the required 'country' parameter. The optional 'number_type' parameter is never mentioned, so its accepted values and effect on the returned rate are undocumented in both the schema and 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?

States a specific verb and resource: 'Returns an indicative monthly phone-number price for a country.' That is clearly distinct from get_data_rate and get_account_balance. It does not, however, differentiate itself from close siblings like quote_number or check_call_rate, which also appear to produce pricing quotes.

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 when-to-use, when-not-to-use, or prerequisite guidance is given. With sibling tools like quote_number, get_data_rate, and check_call_rate in the same pricing family, an agent has no stated basis for choosing this tool over those.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so 'Phone settings are not changed' largely restates the safety profile. The description does add real value by disclosing the return content (fail and warn items), but says nothing about latency, whether the check must be complete, or error behavior for an unknown/stale request_id.

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 tight sentences with the purpose front-loaded and no filler. The second sentence is short but leans on annotations to make its point.

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

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

There is no output schema, so the description should carry return-shape detail; it gestures at 'fail and warn items' but not their structure. Combined with the unlinked request_id and unmentioned sibling, an agent has just enough to call it, not enough to call it 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?

Schema description coverage is 0% and the single parameter is undocumented in the schema. The description only reuses the name 'request_id' as the lookup key, adding no format, origin (which tool produces it), or validity/lifetime semantics, so it does not compensate for the coverage gap.

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

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

States a specific verb and resource ('Returns the result of an eSIM connection check') plus the scope ('for request_id, including fail and warn items'). The retrieval framing implicitly distinguishes it from run_esim_connection_check, but it never names that sibling, so an agent must infer the pairing.

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

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

No explicit when-to-use statement and no named alternative; the requirement of a request_id only implies that a check must already have been run (presumably via run_esim_connection_check). Usage is inferable but not spelled out.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds a genuinely new behavioral fact beyond the annotations: the feature is gated to the Pro plan, which affects whether a call will succeed.

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

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

Two short sentences, front-loaded with what is returned and then the plan constraint; 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?

With no output schema, the description must carry the burden of describing the return value, and 'how this seat's numbers are forwarded' is vague about the actual shape (target numbers, conditions, fallback). It is adequate for a zero-parameter read tool but leaves the response format under-specified.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description correctly does not invent parameter detail.

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?

Clear specific verb (Returns) and resource (this seat's numbers' forwarding), which an agent can distinguish from the sibling update_forwarding. It does not explicitly name that sibling or state it is the read counterpart, but the scope is 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?

Usage is only implied: the read-only nature and the presence of update_forwarding suggest when to call this. The 'Pro plan' note is a gating hint rather than a when-to-use rule, and no exclusions or alternatives are named.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description still adds genuine value by enumerating what comes back: the toggles and the low-balance threshold. With no output schema, this return-content disclosure is the only source of that information.

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 zero waste, front-loading the verb and the returned payload. Nothing could be removed without losing 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 zero-parameter read tool whose annotations carry the safety profile and whose lack of an output schema is compensated by the field list in the description, this is nearly complete. The only minor gap is not pointing at set_notification_preferences for the write 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 tool takes zero parameters, which is the baseline-4 case per the rubric. There is nothing for the description to add semantically, and it correctly does not invent parameter guidance.

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 (Returns) and resource (notification toggles plus the low-balance threshold), and the payload contents immediately separate it from the sibling set_notification_preferences. It is clear but never explicitly names the setter counterpart, so differentiation is implicit rather than stated.

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 read-oriented phrasing implies 'use this to inspect current settings before changing them', but there is no explicit when-to-use statement, no prerequisite, and no mention of set_notification_preferences as the mutation alternative. Adequate but leaving routing to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the useful hint that ports are asynchronous/take time, but says nothing about returned status values, polling expectations, or latency.

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

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

Two short sentences, front-loaded with the purpose. The second sentence is terse and adds a behavioral hint, though it is vague enough to be borderline 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?

No output schema exists, so the description should ideally say what the status values look like and whether polling is expected. Given the tool's simplicity (one required param, a read-only operation), the description is barely adequate but leaves the return shape unexplained.

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% for the single port_id parameter, so the schema alone does not explain the argument. The description does not compensate by describing the identifier's format or where it comes from (e.g., a start_port response).

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 gives a specific verb and resource: it returns the current status of a port request. That is clearly distinct from start_port and quote_port, though it never names or explicitly contrasts with the closest sibling, port_requirements.

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 explicit when-to-use or when-not-to-use statement, and no alternative is named. The sentence 'A port is not instant' implies the tool is meant for checking progress while a transfer is pending, which is only implicit 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?

Annotations already declare readOnly, idempotent, and non-open-world behavior, so safety is covered. The description adds genuinely new behavioral context: the thread is returned oldest-first, no account is required, and only one thread is returned. It stops short of describing pagination or note contents.

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

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

Three short sentences, zero filler, with the core action and lookup key front-loaded before the ancillary constraints. Every sentence carries information an agent needs.

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

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

For a single-parameter read tool with no output schema, the description covers what is returned, the ordering, the auth posture, and the scope limit. The only gap is that it does not sketch what a 'product note' contains, which the agent would otherwise have to infer.

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% for the single conversation_id parameter, but the description ties the parameter to its role ('one product-note thread by conversation_id'). That is the minimum needed; no format, source, or example of a conversation_id is given.

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 ('Returns one product-note thread by conversation_id') and adds the ordering ('oldest first'), so the agent knows exactly what this returns. It does not explicitly contrast itself with the sibling get_thread, leaving a small ambiguity about which thread-retrieval tool to pick.

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 account is required' and 'Does not list other threads' imply the context of use and rule out a listing interpretation, but there is no explicit statement of when to choose this over get_thread or submit_product_note. Usage is only indirectly conveyed.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuinely new behavioral facts beyond annotations: the link is short-lived, requires the Business plan, and requires the recordings.read grant. It does not say what happens if the grant is missing or whether the link expires in a retrievable way.

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 return value, then the authorization gates. Every clause earns its place and there is no filler.

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

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

A read-only one-param tool with no output schema is fairly simple, and the auth/plan gates are the key missing pieces that were supplied. Still, call_id provenance and error behavior on missing plan/grant are unstated, leaving some gaps an agent would want.

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

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

Schema coverage is 0% and the single call_id parameter is undocumented in both schema and description. Baseline for one param without schema documentation is still a 3, and the description adds no format or source hint (e.g., how to obtain call_id). It compensates only weakly.

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

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

States a specific verb+resource ('Returns a short-lived streaming link for a recorded phone call'), which distinguishes it from siblings like get_transcript (text) and get_call (metadata). It does not explicitly name those siblings, so it falls short of a 5.

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

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

Usage is implied by the resource description, but there is no explicit when-to-use/when-not guidance and no routing to alternatives such as get_transcript or search_calls. The mention of plan and scope requirements is a gate, not 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?

Annotations already cover readOnly, idempotent, and non-destructive behavior, so the bar is lower. The description adds genuinely new behavioral detail beyond the annotations: results are ordered oldest-first and 'before' pages toward older messages, which tells the agent how to paginate.

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

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

Two short sentences with zero waste; the core behavior is front-loaded before the pagination 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 small 3-param read tool with no output schema, the essentials (ordering, cursor meaning) are covered. However, the limit bound (max 50) and the conversation_id identifier's origin are left to the schema and inference, so it is adequate but not fully self-contained.

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

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

Schema coverage is only 33%: 'limit' is documented in the schema, but 'conversation_id' and 'before' are not. The description compensates for 'before' by explaining it is an ISO 8601 cursor for older pages, but adds nothing about conversation_id, leaving a gap.

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

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

States a specific verb and resource ('Returns messages in one thread') plus the ordering guarantee. It is clearly distinguishable from search_messages by implying single-thread retrieval, though it never names that sibling 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 on when to prefer this over search_messages, nor any prerequisites or context for use. The reader must infer the thread-reading use case 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the marginal burden is low. The description adds genuinely useful state semantics beyond the annotations: in_progress while the call is live and no_transcript only after the conversation ends with no stored text.

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

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

Three short sentences, front-loaded with the core behavior and the negative scope right after. Every sentence carries information; the only minor cost is the slightly repetitive status phrasing.

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

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

For a one-parameter read tool with no output schema, the description supplies the missing return-state information (in_progress vs no_transcript) that the schema cannot. It stops short of stating what a successful transcript payload looks like beyond 'text', but that is a minor gap.

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

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

The single call_id parameter has no schema description (0% coverage) and is never mentioned in the description. The phrase 'for a phone call' implicitly signals what must be identified, but no format or lookup guidance is added, so it does no more than the schema's required-fields list.

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

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

States a specific verb and resource (returns stored transcript text for a call) and immediately delimits scope with 'Does not start a new transcription.' That negation cleanly separates it from the sibling request_transcript without requiring the agent to open either schema.

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

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

Gives clear conditions for the tool's use and explicitly rules out the transcription-starting case, which is the main confusion risk. It does not, however, name the alternative (request_transcript) so the agent must infer where the excluded case belongs.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description usefully adds the seat-vs-account scoping distinction, but says nothing about response shape, units, or the default look-back beyond what the schema states.

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 tight sentences, front-loaded with the returned resource and followed immediately by the one non-obvious parameter behavior. No filler, though the second sentence is terse enough to feel slightly clipped.

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

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

For a read-only, two-parameter tool with no output schema, the description covers the core purpose and the ambiguous flag. It omits what fields come back and how 'days' bounds the totals, so an agent lacks a little context for interpreting results.

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

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

Schema coverage is 50%: 'days' is documented in the schema, but 'company' has no schema description. The description compensates for 'company' by explaining it means whole-account scope on Business, which is the useful bit; still, no detail on how days interacts with either scope.

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

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

States a specific verb (Returns) and resource (eSIM data balance and minutes used), and pins the scope to 'this seat' vs 'the whole account'. It is clearly distinguishable from get_account_balance and get_data_rate by the seat-level framing, though it never names a sibling to route away from.

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 'company=true covers the whole account on Business' note implies when to use the account-wide variant, but there is no explicit when-to-use, when-not, or alternative-tool guidance against the many get_*/quote_* siblings. Usage is only implied.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive). The description adds genuinely new behavioral context: the response includes the transcript, and include_audio yields a short-lived audio link that is gated to Pro plans and above.

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, zero waste, with the core return behavior front-loaded and the conditional audio detail following. Every clause 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?

With no output schema, the description correctly names the returned content (voicemail plus transcript) and the optional audio link. Nothing critical is missing for a two-parameter read tool whose annotations cover safety.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: include_audio is explained as producing a short-lived audio link with a plan restriction, and call_id is tied to selecting the voicemail. Format details for call_id are still absent.

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

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

States a specific verb and resource with scope: 'Returns one voicemail by call_id'. The singular 'one' implicitly separates it from list_voicemails, but no sibling (e.g. get_recording, get_transcript) is named 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 statement of when to call this versus list_voicemails or get_transcript, and no preconditions beyond the implied need for a call_id. The agent must 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?

Annotations already declare this is a non-read-only, non-idempotent, open-world mutation, so the description does not need to restate the safety profile. It adds genuine context beyond them: the invitation is delivered by email to an external recipient, and Free/Pro accounts are capped at 8 people, a hard constraint that determines whether the call succeeds.

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

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

Two short sentences with no filler, and the core action is front-loaded ahead of the constraint. The second sentence is telegraphic ('stop at 8 people') and does not say what happens when the cap is hit, so it is slightly under-explained rather than padded.

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

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

For a one-parameter mutation whose annotations cover safety, the description is minimally adequate: purpose plus one plan constraint. It omits who may invite (admin role), what happens on a duplicate invite, and what the caller gets back, with no output schema to fall back on.

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 'email' parameter has 0% schema description coverage, so the description carries the burden here. 'Invite a person' / 'Emails an invitation' implies one address per call rather than a batch, which is mild added meaning, but there is no guidance on format, validity, or behavior for an address that already has an account.

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

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

States a specific verb and resource — it emails an invitation to join 'this Widely account' — which no sibling tool does, so it is distinguishable without opening the schema. It stops short of explicitly naming what it is not (e.g. it does not add a user directly or resend an existing invite).

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 explicit when-to-use or when-not-to-use guidance and no alternatives are named. The one implicit guideline is the plan cap ('Free and Pro stop at 8 people'), which tells the agent the call will be rejected on lower tiers once the team is full, but prerequisites such as the caller's admin permission are unstated.

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

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

The annotations already establish readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description still adds real value beyond them by disclosing that inactive numbers pending identity registration are included in the result, which is a behavioral nuance an agent would not otherwise know.

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 front-loaded sentence that states the resource first and then the one qualifying detail. No filler, no restatement of the title or 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 no-parameter, no-output-schema list tool, the description covers what is returned and one important edge case (inactive numbers). It could say a bit more about the returned shape (e.g. what identifies each number), but nothing essential to calling it is missing.

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

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

The tool takes zero parameters, so there is nothing to disambiguate; per the rubric this is the baseline 4. No schema or description detail is missing on the parameter side.

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

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

States a specific verb and resource ('Returns this account's phone numbers') and scopes it to the caller's own account, which implicitly separates it from search_numbers (catalog search) and quote_number. It stops short of explicitly naming those siblings, so the distinction must be inferred.

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?

Usage is implied by the 'this account's phone numbers' scoping, but there is no explicit when-to-use guidance and no named alternative for the closely related search_numbers or list_identities tools. The agent has to infer that this is the inventory-listing tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description's added value is disclosing return content (provider per identity, and 'what it can do'), which matters because no output schema exists, but it says nothing about ordering, volume, or pagination.

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 front-loaded sentence that leads with the verb and then enumerates the resource types in order of specificity. Every clause earns its place by telling the agent exactly what comes back.

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

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

With no output schema, the description does the work of explaining the return payload: identity types, supplying provider, and capabilities. That is sufficient to call the tool correctly, though the absence of any usage routing leaves the sibling-choice decision to the 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?

Only one optional parameter (include_shared) at 100% schema description coverage, so the schema already carries the meaning. The description does not mention the shared-numbers option or clarify its business-account scope, so it adds nothing beyond the structured field; this is the expected baseline when the schema is complete.

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

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

States a specific verb (returns) and enumerates the exact resources covered: phone numbers, caller IDs, verified SIMs, PBX extensions, and eSIMs, scoped to 'this Widely seat'. It is distinguishable from narrower siblings like list_did_numbers or list_pbx by being a superset, though it never names those siblings 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 on when to use this tool versus alternatives such as list_did_numbers, list_pbx, or search_numbers, and no prerequisites or conditions stated. The 'on this Widely seat' phrasing hints at scope but the agent must infer that this is the comprehensive listing tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds one useful negative fact (no processor id returned), which prevents an agent expecting to hand off a processor token, but little else.

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

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

Two short sentences, front-loaded with the returned resource and fields, with the exclusion placed last. 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 zero-param, no-output-schema read tool the core is present, but with no output schema the description should at least note the return shape (e.g., list vs single, pagination) and when to reach for it over sibling list_ tools.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4; there is nothing for the description to clarify or compensate for.

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

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

States a specific verb (Returns) and resource (masked saved cards and bank methods) with the exact fields exposed, which distinguishes it from siblings like get_account_balance or list_wallet_activity.

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

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

Provides no guidance on when to use this versus adjacent tools (e.g., get_account, list_wallet_activity) and no exclusions or prerequisites. Usage is only implied by the list_ naming prefix.

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

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

Annotations already carry the safety profile (readOnlyHint, idempotentHint, destructiveHint, openWorldHint), so the description's burden is lower. The 'Business plan' note adds a plan-availability constraint not present in annotations, which is useful. But it doesn't elaborate what that qualification means or what the shapes of returned entities are.

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

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

Two short sentences, front-loaded with the resource. 'Business plan.' as a bare fragment is terse to the point of ambiguity but does convey a constraint 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?

For a zero-param read-only list tool with annotations covering behavior, the description is nearly sufficient. The main gap is the unexplained 'Business plan' qualifier and the lack of any distinction from sibling listing tools (list_did_numbers, list_phone_system), which leaves the agent guessing which to call.

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?

Zero parameters, so the baseline is 4. There are no parameters to describe, and the schema is closed (additionalProperties false). No further parameter context is needed.

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

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

States a specific resource: shared numbers and phone menus on the account. The verb 'Returns' is a bit weak, and it doesn't distinguish itself from siblings like list_did_numbers or list_phone_system, but an agent can identify the resource clearly.

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 when-to-use guidance, no alternatives named, no exclusions. The phrase 'Business plan' hints at a prerequisite but is terse and unexplained — it's unclear whether it means the feature is only available on Business plan, or only queries Business-plan accounts. No routing to sibling tools is provided.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so safety is covered. The description adds a genuinely useful behavioral nuance beyond the structured fields: 'A queue rings only members who are signed in and available.' That discloses queue semantics not available elsewhere.

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

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

Two short sentences, front-loaded with the returned contents, and the caveat about queue ringing is the only sentence that follows. No filler or repetition.

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

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

With no output schema, the description carries the burden of explaining return values and enumerates the entity types returned. It does not cover format or pagination, but for a parameterless read-only list tool it is essentially 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 tool takes zero parameters, so there is nothing for the schema to document and no parameter meaning the description must supply. Baseline 4 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 names a specific resource set (numbers, AI receptionists, press-1 menus, queues, opening hours) and effectively states the verb as 'Returns'. An agent understands what it gets, though it does not explicitly differentiate itself from the nearby list_pbx sibling.

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 statement of when to call this versus alternatives, nor any exclusions or prerequisites. The usage is only implied by the read-vs-upsert relationship with upsert_queue, upsert_menu, and upsert_receptionist.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false. The description still adds genuinely new context: no authentication is required, which the annotations do not express. 'Does not change the plan' largely restates destructiveHint=false, so the added value is real but partial.

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

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

Three terse sentences, front-loaded with what is returned, then the access constraint, then the non-mutation note. Efficient overall, though the final sentence overlaps with annotation-declared behavior.

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

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

For a single optional parameter, read-only listing tool with no output schema, the description actually sketches the return content (the three plan tiers and monthly prices). That is close to complete; only alternative-routing guidance is absent.

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 single currency parameter is fully documented there (GBP/EUR/USD/ILS, default EUR). The description adds no currency syntax or defaulting behavior beyond the schema, 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 states a concrete verb and resource (returns list prices) and names the exact data set (Free, Pro, Business monthly prices). This cleanly separates it from rate/quote siblings like get_data_rate or quote_call, which return different pricing concepts.

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

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

It supplies a useful precondition ('No sign-in') and a negative scope note ('Does not change the plan'), which imply a safe informational lookup. However, it never states when to prefer this over related pricing tools (quote_call, get_did_rate, get_data_rate), so usage is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only that the result mixes confirmed members with pending invites, which is modest added context about return content rather than behavior. No pagination, auth, or scoping details are given.

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 front-loaded sentence with no filler or redundancy. Every word carries information, and the return content is stated up front.

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

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

For a zero-parameter read-only list tool with annotations covering safety and no output schema, the description adequately conveys what is returned (people plus pending invites). It could be slightly more complete by noting scoping or ordering, but nothing critical for correct invocation is missing.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description does not need to explain parameter syntax, and it correctly does not attempt to.

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

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

States a clear verb (returns/lists) and resource (people on the account plus pending email invites), so the agent knows exactly what it retrieves. It does not, however, explicitly distinguish itself from related siblings like list_identities or invite_member, which an agent might reasonably confuse with the 'people on this account' framing.

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 when-to-use guidance, no mention of prerequisites, and no routing to alternatives. The 'pending email invites' content implies a possible relationship to invite_member, but the description never states that connection. Usage is only inferable from the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds useful disclosure about the response payload and the conditional transcript ('when one is stored'), but says nothing about ordering, pagination, or truncation behavior.

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

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

A single front-loaded sentence that states scope first, then the payload. Every clause carries information and nothing is padded.

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

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

With no output schema, the description does carry the minimum return-value information (caller, time, duration, transcript). However, it omits ordering, pagination/limit behavior, and how to retrieve the full transcript or a single voicemail, which are material for a listing tool with a get_voicemail sibling.

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 both optional parameters (days, limit) are documented in the schema itself with defaults and bounds. The description adds no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.

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

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

The description names a specific verb (Returns) and resource (voicemails) plus the scope 'on this seat', and it enumerates the returned fields (caller, time, duration, transcript). It does not, however, distinguish itself from the sibling get_voicemail, so an agent must infer that this is the bulk/recent listing.

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 when-to-use guidance, no mention of the get_voicemail alternative for a single item, and no exclusion criteria. 'Recent' is the only usage signal and it is undefined in the description (the 30-day default lives only in the 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful content about what the ledger contains and that each row carries a customer label, but says nothing about pagination behavior, default ordering, or whether results are bounded by the limit/offset pair.

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

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

Two short sentences, front-loaded with the resource and its contents, with zero filler. Nothing needs trimming.

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

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

With no output schema, the description reasonably covers what a row contains, and annotations cover the safety profile. However, for a paginated list tool with two undocumented parameters, the missing paging guidance leaves a real gap 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?

Schema description coverage is 0% and both parameters (limit, offset) are undocumented in the schema. The description does not compensate at all: it never mentions pagination, the maximum limit of 200, or what offset does. An agent must guess the paging contract.

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 ('Returns the wallet ledger') and enumerates the entry types (top-ups, product debits, holds), which clearly differentiates it from general account tools. It does not explicitly contrast with the closest sibling, list_wallet_refunds, so sibling differentiation is left to inference.

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 statement of when to call this tool versus alternatives such as list_wallet_refunds, get_account_balance, or explain_charges. The agent must infer usage purely from the resource 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?

Annotations already declare the full safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description goes beyond them by disclosing the business rules that determine eligibility — profile not installed and inside the refund window — which is genuine behavioral context an agent could not infer from the annotations.

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

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

One tight sentence with the verb and result front-loaded and the qualifying conditions appended after a colon. No filler, no repetition of the title.

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 parameterless, read-only list tool with no output schema, the description covers what is returned and the exact qualifying conditions, which is the essential information. It could optionally note the return shape or ordering, but nothing critical is missing.

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

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

The tool takes no parameters, so the baseline is 4. The description adds no parameter meaning because there is none to add, and schema coverage is 100% regardless.

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

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

States a specific verb (Returns) and a precisely scoped resource (first-eSIM wallet top-ups refundable to the card), which inherently separates it from list_wallet_activity. It does not, however, name or contrast against any sibling, so it stops short of the top mark.

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 eligibility criteria ('profile has not been installed', 'inside the refund window') imply when the tool is relevant, giving a competent agent enough to act. But there is no explicit when-to-use statement, no exclusions, and no routing to alternatives such as list_wallet_activity.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds two pieces of context not in the annotations: no authentication is required, and the call has no submission side effect. That is genuine added behavioral value, though return shape is unspecified.

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

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

Three short sentences, zero waste, with the core purpose front-loaded and the two constraints following as quick clarifiers.

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

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

For a zero-parameter, read-only lookup with no output schema, the description is nearly complete: it says what comes back (documents) and what it does not do. It could briefly indicate what form the document list takes, which is the only minor gap.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly implies no inputs are needed by describing a static lookup, and nothing in the schema requires further 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 names a specific verb and resource: it returns the documents a number port requires. It implicitly distinguishes itself from start_port by stating 'Does not submit a port', though it does not name that sibling 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?

Usage is implied by the negations ('No sign-in', 'Does not submit a port'), which tell the agent this is a pre-flight lookup rather than the port submission itself. However, no positive when-to-use condition or named alternative (e.g. start_port, quote_port) is given.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description still earns credit for adding two facts not in the annotations: no authentication is required ('No sign-in') and no call is placed ('Does not dial'), which directly answers the side-effect question for a quote tool.

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

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

Two short sentences, front-loaded with what the tool returns and followed immediately by the two constraints that matter most (no sign-in, no dialling). Zero waste.

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

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

For a simple, read-only, no-output-schema quote tool this is nearly complete: the return intent and the two key behavioral constraints are stated. The remaining gap is that it never clarifies the country-vs-destination relationship or how it differs from check_call_rate.

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

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

Schema coverage is 50%: currency and destination are described in the schema, while country and number_type are undocumented in both places. The description hints that a number OR a country can be supplied (suggesting alternative inputs) but adds no format, enum, or mutual-exclusion detail beyond that baseline hint.

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

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

States a specific verb and resource ('returns the rate-checker price') plus the two things that can be priced (a number or a country). However, it does not distinguish itself from the very similar sibling check_call_rate, nor from quote_number, which is a real ambiguity for an agent choosing among rate tools.

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

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

'No sign-in. Does not dial.' implies this is a safe, non-authenticated pre-check operation, which is useful context. But there is no explicit when-to-use or when-to-use-an-alternative guidance, and the near-duplicate sibling check_call_rate is never addressed.

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

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

Annotations already cover read-only, idempotent, non-destructive, and closed-world. The description adds valuable context: no sign-in required, billing granularity of 0.1 GiB, and that there is no fixed data package. This goes beyond what annotations provide, though it doesn't discuss rate limits or error behaviors.

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

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

Three short sentences, front-loaded with the core purpose and pricing model, then optional parameter behavior and a key constraint (no sign-in). No wasted words.

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

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

Given annotations cover safety and idempotency, and no output schema exists, the description is largely complete: it explains the pricing model, optional estimation, billing granularity, and no sign-in requirement. Minor gaps remain around country parameter semantics and how the currency default is determined, but nothing critical for a read-only quote 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 67%. The description explains the gb value as optional for estimates and billed in 0.1 GiB steps, which adds meaning. However, it does not explain the country parameter or the currency options beyond what the schema already provides. The description partially compensates for the coverage gap but leaves country semantics unclear.

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

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

States a specific verb (quote) and resource (eSIM data), and clarifies the pricing model as pay-as-you-go per GB with no data package. Distinguishes from siblings like get_data_rate and get_esim_connection_check implicitly through the 'rate-checker' terminology, though it could be more explicit about the distinction.

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

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

Provides clear context that this returns a per-GB price and that an optional gb value gives an estimate. Implies usage for pricing queries but does not explicitly state when to use this over get_data_rate or other quote tools. Explicit alternatives are missing 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?

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds context the annotations cannot: no authentication is required and the call has no purchasing side effect, which is genuinely useful behavioral framing for a pricing 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?

Three short, front-loaded sentences with no filler; the core output (monthly price, call inclusion) leads and the caveats follow.

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?

It does convey the return shape conceptually, which matters since there is no output schema, and the exclusion of purchasing is stated. However, with two of three parameters undocumented anywhere, the definition is not complete enough to call the tool correctly without guesswork.

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 only 33% (only currency is documented in the schema), and the description mentions no parameters at all. It does not explain what country or number_type accept or how they change the quoted price, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource: returns the rate-checker monthly price for a number plus whether calls are included. It is clearly distinct from the other quote_* siblings (quote_call, quote_esim, quote_port) by resource, though it never names 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 sign-in' and 'Does not purchase a number' give clear conditions for use and a hard exclusion that prevents the agent from treating this as a purchase step. It stops short of naming a purchase/ordering alternative, so the negative guidance is implied rather than explicitly routed.

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

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

Adds real context beyond the annotations: 'No sign-in' is an auth disclosure not captured by readOnlyHint/idempotentHint, and 'The move is not instant' warns about latency of the eventual action. It stops short of describing the return shape or any rate limiting.

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

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

Three short, front-loaded sentences with no filler. The core action (returns price) comes first, followed by the two key behavioral caveats.

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?

There is no output schema, so the description should at least hint at what the price response contains (e.g., currency handling), and it leaves three of four parameters unexplained. Adequate for a read-only quote tool but with visible gaps.

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

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

Schema description coverage is only 25% — currency is documented, but number, country, and number_type are bare in the schema and completely unmentioned in the description. With four parameters and three undocumented, the description fails to compensate.

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

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

States a specific verb+resource: returns the rate-checker price to port an existing number to Widely. It clearly separates itself from siblings like get_port (status) and start_port (executing the move) by saying it 'does not start the move.'

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?

Implies the tool is a pre-move quote ('Does not start the move') but never names start_port or port_requirements as the alternatives to use next. The context is inferable 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?

Annotations already cover readOnly, idempotent, and non-destructive, so the safety profile is given. The description adds real context beyond that: deterministic ordering ('oldest first'), the permission model ('any connected account can read it'), and an explicit scope exclusion ('other chats are not included').

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

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

Three short sentences, front-loaded with what is returned and the ordering, then permissions, then scope. No filler or repetition; every clause carries 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, well-annotated read tool with a fully documented single parameter and no output schema, the description covers purpose, ordering, access, and scope. Only pagination/return-shape detail is absent, which is minor here.

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

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

Schema coverage is 100% for the single 'limit' parameter, so the schema already documents it. The description adds nothing about limiting or pagination behavior, which is the correct baseline of 3 when the schema carries the parameter burden.

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

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

States a specific verb (returns) and resource (messages in this user's Support chat) plus an ordering guarantee (oldest first). The clause 'Other chats are not included' scopes it apart from thread/message readers, but it never names a sibling tool, so differentiation is implicit rather than explicit.

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

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

'Any connected account can read it' clarifies access but is not a when-to-use rule. There is no guidance on when to pick this over ask_support, search_help, or get_thread, 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?

Annotations establish the safety profile (not read-only, open-world, not idempotent, not destructive), and the description adds genuine behavioral detail beyond them: the two-step ring-then-dial flow, that the user speaks on the resulting outgoing call, and the important abort condition that no phone answering means the destination is never dialled. The 'Pro plan' note also flags an entitlement requirement.

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 core ring-then-dial behavior is front-loaded in the first two sentences, and there is no wasted filler. The subsequent short declaratives ('The user speaks on it. Pro plan.') are a bit staccato, but each carries a distinct fact.

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

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

For a two-parameter call-placement tool with no output schema, the description covers the execution flow, the abort condition, the plan requirement, and how the result manifests. It does not address permissions on identity_id or call failure modes beyond 'no answer', which keeps it just short of 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%, so both destination and identity_id are already documented in the schema. The description references the destination concept ('dials the destination') but adds no format, validation, or identity_id semantics beyond the schema, so the baseline 3 applies.

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

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

The description gives a specific verb and mechanism: it rings the user's phones, then dials the destination into the answered conversation, producing an outgoing call. This is clearly distinct from siblings like control_call or quote_call. It stops short of explicitly naming what it is not, so it earns a 4 rather than a 5.

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

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

The only usage signal is the terse 'Pro plan' prerequisite, which is useful but not framed as a condition for choosing this tool. There is no statement of when to use request_call versus alternatives such as control_call, request_speak, or quote_call, 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?

Goes beyond the annotations (which only say non-read-only, open-world, non-idempotent) by disclosing asynchronous behavior: 'Returns immediately with call_id', 'An empty transcript means speaking is still in progress', and the exact effect of connect_user on the user's phones. It does not cover failure modes, cost, or what happens if the call fails, keeping it short of a 5.

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?

Short, front-loaded sentences with the core action first and the return/transcript semantics after. Some sentences duplicate the schema's connect_user wording, which is minor waste.

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

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

With no output schema, the description usefully explains the immediate call_id return and how to interpret an empty transcript, plus the connect_user side effects and plan gate. The main gap is the undocumented identity_id parameter and any failure/cost behavior.

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

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

Schema coverage is only 50%, and the description mostly restates the schema's own connect_user text verbatim, which earns no credit. It implies destination is the dialed number but says nothing about identity_id, which is documented nowhere, so the coverage gap is not compensated.

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

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

States a concrete action (dials a number, assistant handles the task on the phone) with enough specificity to be understood. However, it never distinguishes itself from the sibling request_call or quote_call, so an agent cannot tell which one to pick from the description alone.

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 'Business plan' note gives one prerequisite, which is useful context. But there is no explicit when-to-use / when-not-to-use guidance and no reference to the alternative calling tools, so routing between request_speak, request_call and quote_call is left to inference.

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

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

Annotations already disclose readOnlyHint=false and idempotentHint=false, so the mutating/non-idempotent nature is covered structurally. The description adds the 'Pro plan' entitlement gate, which is real value beyond the annotations, but it omits whether the call is asynchronous, whether it consumes credit, and how the resulting transcript is retrieved.

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, front-loaded sentences with no filler; the scope condition and the plan constraint are stated immediately. It is efficient, though extremely terse.

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 mutation/request tool with no output schema, the description should say what happens after the request (queued job, credit use, where the transcript surfaces). None of that is covered, and the lone required parameter is undocumented, so an agent cannot call it 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 single parameter call_id has 0% schema description coverage, and the description never mentions it. The description therefore adds no meaning about which call to transcribe or the expected identifier format, failing to compensate for the coverage gap.

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

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

States a specific verb+resource ('transcribe a recording') and adds a distinguishing condition ('that has no text yet'), which implicitly separates it from get_transcript. It does not name the sibling explicitly, so it falls short of the 5-level 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?

'A recording that has no text yet' implies the condition for calling it, and 'Pro plan' implies an entitlement prerequisite. However, it never names get_transcript as the alternative for recordings that already have text, leaving the routing to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, and the description adds genuinely new context: this is an async request that returns a request_id, the no_install_yet outcome means the profile may have been QR-installed with no Widely app present, and no APN is included.

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

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

Three short, front-loaded sentences; the action and return value come first and the edge-case meaning follows. The trailing 'An APN is not included' is slightly cryptic but still 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?

No output schema, and the description does cover the request_id return and the no_install_yet semantics, which is helpful. However, it omits how to retrieve the result (the obvious get_esim_connection_check poll) and leaves both input parameters unexplained, so an agent lacks enough to invoke it 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?

Schema description coverage is 0% for sim_id and device_id, so the description carries the full burden of explaining them, and it says nothing about either parameter. The reader cannot tell what sim_id identifies or how device_id relates to the target handset.

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

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

States a specific verb and resource (check the eSIM connection via the user's Widely app) and notes it returns a request_id, which signals an async trigger. It doesn't explicitly differentiate itself from the sibling get_esim_connection_check, leaving the poll/trigger relationship to inference.

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?

Implies a precondition (the user's Widely app must be reachable) and gives diagnostic context for a no_install_yet result, but never states when to call this versus get_esim_connection_check or the install-step siblings. Usage is implied rather than specified.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so safety is covered. The description adds value beyond them by disclosing the return shape (one row per call with direction, duration, outcome, identity, and transcript/recording presence) even though no output schema exists. It stops short of describing pagination or the seat-scoping behavior.

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

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

Two sentences, zero waste: the first front-loads what the tool searches by, the second front-loads what it returns. Every clause 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 10-parameter tool with no output schema, the description covers the primary filters and the return shape reasonably well. However, it omits transcript-text search ('query'), missed_only, line selection, and any pagination guidance, leaving real gaps for an agent to discover only in the 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?

With 70% schema coverage, the schema already documents days, limit, since, until, number, and contact, and the description's filter list largely duplicates those. It omits notable parameters such as the transcript-word 'query', 'line', and 'missed_only', so it adds only marginal meaning over the structured 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 names a specific verb ('Finds') and resource ('phone calls on this Widely seat'), and enumerates the filter dimensions (date range, direction, contact name, number). That resource noun cleanly separates it from siblings like search_contacts, search_messages, and search_numbers, though it never explicitly contrasts with the single-call sibling get_call.

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?

Usage is implied rather than stated: an agent can infer 'use this to find calls matching filters,' but there is no when-to-use/when-not guidance, no mention of when to prefer get_call for a single call, and no note on result limits or paging. Adequate but with clear gaps.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description usefully adds the data scope ('this seat') and, in the absence of an output schema, what is returned ('names and phone numbers').

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

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

Two short sentences, front-loaded with purpose and scope, with the return information in the second sentence. No filler or redundancy.

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

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

For a simple two-parameter read-only search, the definition covers purpose, scope and return shape. It still omits what 'limit' controls, whether matching is prefix/substring/phone-digit, and any empty-result or pagination behavior.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate. 'By name' implies the query is a name string, but the 'limit' parameter (1-25) is never explained in the description or schema, leaving its meaning undocumented.

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

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

States a specific verb and resource ('Finds saved contacts') plus the scoping constraint ('on this seat') and the match key ('by name'). An agent can distinguish it from search_calls/search_messages/search_numbers by resource, though no sibling is named 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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives among the many sibling search_* tools. The 'saved contacts on this seat' phrase scopes the data but does not tell the agent when this tool is the right choice.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds two useful facts beyond that: no authentication is required, and pricing is out of scope for the return payload.

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

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

Three short sentences, the core behavior front-loaded, and each clause (no sign-in, no price) adds information rather than restating the name. Nothing is wasted.

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

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

For a one-parameter lookup with no output schema and full annotation coverage, the description covers scope and auth adequately. The remaining gap is the missing boundary against ask_support, which matters in a sibling set this large.

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

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

Schema coverage is 0% and the single 'query' parameter is undocumented in the schema, so the description must carry the load. Saying it answers 'a question' does imply the parameter is natural-language input, which is meaningful, but no format, length, or phrasing guidance is given.

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

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

States a specific verb and resource: returns public product facts and in-app menu names for a question. This clearly separates it from data-fetching siblings like get_account or search_calls, though it never explicitly names or contrasts with the closest sibling, ask_support.

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 when-to-use guidance and no alternative named. 'No sign-in' and 'Does not return a price' are scope exclusions, not routing rules, so an agent cannot tell from the description whether a given question belongs here or with ask_support.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely new behavioral context beyond those fields: the result contents (message text with sender and thread) and the exclusion of support and assistant threads. It stays silent on result limits/pagination behavior, which keeps it short of a 5.

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, zero filler, with the resource scope and the exclusion rule front-loaded before the return-shape detail. Every clause carries information an agent needs.

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

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

With no output schema, the description usefully states what comes back (message text with sender and thread). Annotations cover the safety profile. The only gap is that conversation_id is defined nowhere, which is a minor incompleteness for a 4-parameter search tool.

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

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

Schema coverage is 75%, and the three documented parameters (days, limit, query) are already explained in the schema. The description restates keyword and date filtering but adds no syntax, defaults, or format detail, and conversation_id remains undocumented in both places. Baseline 3 for high schema coverage applies.

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

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

States a specific verb (Searches) and resource (this user's Widely, SMS, and WhatsApp threads) with the matching dimensions (keyword and date), and gives the return shape (message text with sender and thread). It also names what is out of scope (support and assistant threads), which separates it from read_support and search_calls without opening their schemas.

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

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

Usage is implied by the scope note that support/assistant threads are excluded, which hints at when this tool is and isn't the right one. However, no alternative is named and no prerequisite or context for choosing it over get_thread or read_support is given, so the guidance stays inferential 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safe-read profile is covered structurally. The description adds genuinely useful context beyond that: no authentication/sign-in is required, and it explicitly does not purchase, clarifying the side-effect-free nature of 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?

Three short sentences, front-loaded with the core behavior (what is returned) before the constraints. Every clause carries information — scope, price basis, auth status, and the no-purchase boundary — with zero filler.

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

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

For a 4-parameter read-only search with no output schema and a well-covered input schema, the description is largely sufficient: it explains what is returned and the pricing basis. It stops short of describing result shape (e.g., pagination, per-number fields), but with no output schema declared that omission is minor.

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 75% (country, currency, number_type all documented in-schema), so the schema carries most parameter meaning and the baseline is 3. The description adds only that city is optional and that pricing is the rate-checker list price; it adds nothing on currency options or number_type semantics beyond the schema.

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

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

States a clear verb+resource+scope: returns available phone numbers filtered by country and optional city, with the monthly rate-checker list price. This is specific, but it does not distinguish itself from nearby siblings like quote_number, list_did_numbers, or get_did_rate, so an agent must infer the difference.

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 one useful boundary — 'Does not purchase a number' — and notes no sign-in, implying this is a browse/preview step. However, it never names the alternative tools for pricing (quote_number) or purchasing, nor states positively when this should be chosen over them, leaving selection partly to inference.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, and destructiveHint=false, so the mutation and non-idempotent nature are known from structured data. The description adds valuable timing semantics ('Sending happens on this request'), clarifying that the send is immediate rather than queued, which is not inferable from annotations. It does not discuss error/failure outcomes or delivery semantics beyond immediate dispatch.

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

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

Three short sentences, front-loaded with the primary action and target, then prerequisites and timing. No filler or repetition; each sentence serves a distinct purpose.

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

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

For a mutation tool with annotations covering safety profile and no output schema, the description covers the core action, target, plan requirement, and immediate-send behavior. It stops short of failure modes, delivery outcomes, or channel selection guidance. Adequate but with clear gaps for an agent deciding whether and how to call 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?

Schema description coverage is 100%; all three parameters are described in the schema. The description adds no parameter-level detail (e.g., format of phone number, Widely channel selection, identity_id usage). Baseline 3 applies when the schema carries parameter semantics.

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

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

States a specific verb (sends) and resource (SMS or Widely message) with immediate channel targets (phone number or saved contact). Clearly distinguishable from read-oriented siblings like search_messages and get_thread.

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

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

Mentions 'Pro plan' as a prerequisite, which is useful context. However, there is no explicit when-to-use guidance versus alternatives (e.g., when SMS vs Widely channel is chosen, or relation to request_speak/request_call). Usage is implied but not framed.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false. The description's only addition is 'This request stores the setting,' which is vague and largely restates the write hint; it does not explain whether amount/threshold are ignored or required when enabled=false, nor why the operation is flagged non-idempotent.

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 compact sentences with the core action front-loaded and no filler. The trailing 'This request stores the setting' is the one low-value sentence, but the overall size 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 mutation tool with four undocumented parameters, one required flag, and no output schema, the description leaves key behavior unexplained: the role of payment_method_id, conditional requirements on amount/threshold, and the effect of disabling. It is not complete enough to call correctly with confidence.

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

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

Schema description coverage is 0% for four parameters, so the description must carry the load. It names threshold and amount but gives no units, defaults, or ordering constraints, and never mentions payment_method_id or what enabled=false does to the other 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?

States a specific verb ('turns ... on or off', 'sets') and resource ('auto top-up') plus the fields it controls (threshold, amount). The write orientation implicitly contrasts with the sibling get_auto_topup, though it never names it.

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 when-to-use guidance, no prerequisites, and no mention of the obvious alternative get_auto_topup for reading the current configuration. The agent must infer that this is the write counterpart purely 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say whether omitted notification types are left unchanged or reset, whether the update merges or replaces, or what permissions are required — the most important behavior for a settings 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably under-specified rather than optimally concise given the tool's complexity.

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 mutation tool with no output schema, a nested object parameter, and zero required fields, the description should clarify merge/partial-update semantics and the effect of omitted fields. It leaves all of that to inference.

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

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

Schema coverage is 50%: 'types' is documented as a partial map, but low_balance_threshold has no description. The description names both concepts but adds no semantics (e.g., currency units for the threshold, merge semantics for types) beyond what the schema already conveys, so it does not compensate for the coverage gap.

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

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

States a specific verb (updates) and resource (notification toggles and low-balance threshold), which is more precise than the title. It implicitly contrasts with the sibling get_notification_preferences (read vs write) but never names it or any alternative 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 on when to use this versus get_notification_preferences, no mention that a partial map is acceptable, and no prerequisites or preconditions stated. The agent must infer usage from the verb 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?

Annotations already declare this is a non-destructive, non-idempotent mutation, so the safety profile is covered. The description adds the closed_target behavior and the Business plan requirement, which is real value. It still omits what happens to prior routing (overwrite?), whether changes are immediate, and whether number vs number_id are alternatives.

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

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

Three tight sentences with the action and target list front-loaded and no filler. Dense but every clause carries 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 an 8-parameter configuration tool with no required fields, no output schema, and no parameter documentation, the description is too thin. It should at least disambiguate the *_id vs name parameter pairs and note whether routing overwrites existing settings.

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

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

Schema coverage is 0% across 8 parameters, so the description carries the full burden. It explains the target values and the closed_target concept, but leaves number vs number_id, target vs target_id, auto_record, and time_group_id entirely undocumented, so an agent cannot tell how to populate most 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?

States a specific verb ('Points a number at') and enumerates the exact routing targets, so the resource and action are unambiguous. It does not name or differentiate from siblings like upsert_receptionist/upsert_queue, which define those targets rather than route to them, so it falls short of a 5.

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

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

Provides a prerequisite ('A shared line, receptionist, menu, or queue needs Business'), which is useful context. However, it gives no when-to-use guidance versus the upsert_* siblings that create the receptionist/menu/queue objects this tool routes to, leaving the workflow relationship to inference.

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

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

Annotations already declare this is a non-read-only, non-idempotent, non-destructive write. The description adds real behavioral context beyond that: the move is asynchronous ('not instant') and it explicitly 'Does not send the request to the carrier,' which tells the agent the request is staged rather than dispatched. It stops short of 5 by not stating what a repeat call does or what permissions are required.

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

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

Three tight sentences that front-load the action and reserve the last two for important behavioral caveats. The phrase 'using the details supplied here' is mild filler, keeping it just under a 5.

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

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

With no output schema, five undocumented parameters, and no annotation detail beyond safety hints, the description leaves key gaps: whether a port identifier is returned, how to track progress (get_port), and which of the five fields are required when zero are marked required.

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% across 5 parameters, and the description contributes nothing beyond 'using the details supplied here.' It does not clarify the ambiguous coexistence of 'number' and 'numbers,' the meaning of 'number_type,' or which fields are actually needed to open a valid request.

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

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

States a specific verb+resource: 'Opens a request to move an existing number to Widely.' An agent can tell this initiates a number port rather than quoting one. It does not name or differentiate itself from close siblings like quote_port, port_requirements, or get_port, so it stops short of a 5.

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

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

Usage is implied by the purpose (initiate a port for an existing number), but the description gives no explicit when-to-use guidance or prerequisites. It never says to run port_requirements or quote_port first, nor how to follow up once a port request exists.

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

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

Annotations already declare write, open-world, non-idempotent, and non-destructive behavior. The description adds useful context beyond that: no account is required, reply_url receives each desk reply when https, and the call returns a conversation_id that can extend the thread.

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

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

The description is front-loaded and has no filler; every sentence adds either scope, account requirements, or return/threading behavior. It is compact and easy to scan.

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

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

For a mutation tool with annotations and no output schema, the description covers the essential behavior: purpose, no account required, reply_url handling, and the return value. It does not fully document all parameters, but the core call semantics are clear.

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 only 40%, so the description should carry more of the parameter burden. It clarifies reply_url and conversation_id, but largely repeats the schema's own descriptions and leaves kind, title, and text undocumented.

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

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

States a specific verb and resource: sends a product note to Widely about a missing capability, complaint, or use case. The resource is distinct from the read sibling get_product_note, but the description does not explicitly differentiate it from ask_support or send_message.

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

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

The note types provide context for when to use the tool, and the conversation_id sentence explains how to continue a thread. However, there is no explicit guidance on when to choose this over ask_support or send_message, nor any when-not-to-use condition.

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

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

Annotations provide the safety profile (readOnlyHint=false, openWorldHint=false, destructiveHint=false), so the bar is lowered. The description still adds real context beyond them: it names the three deliverable events, defines the omit-events default, and clarifies that an empty URL stops delivery — behavior the agent could not infer from annotations alone.

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

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

Three short sentences, front-loaded with the core action and the exact events, followed by default and stop behavior. No filler, no redundancy across sentences.

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

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

For a two-parameter setter with no output schema, the description covers the deliverable events, the default, and the stop case, which is what an agent needs to call it correctly. It is slightly thin on replacement semantics (whether setting a URL overwrites a prior subscription), which keeps it from a 5.

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

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

Schema description coverage is 100%, so the schema already documents both parameters and their empty/omit semantics. The description's statements about events and webhook_url largely restate what the schema descriptions say, adding no syntax or format detail beyond them. Baseline 3 applies when 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?

States a specific verb and resource — sets the webhook URL that receives call.started, call.ended, and speak.completed for this seat — and enumerates the exact event names. No sibling tool covers webhook subscription, so there is nothing to disambiguate against, and an agent can identify the operation immediately.

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

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

The description explains operational conditions (omitting events receives all three; an empty webhook_url stops delivery) but never states when to reach for this tool versus any alternative. With no competing sibling, usage is implied rather than contradictory, which fits a 3.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds one useful trait not in annotations – that no authentication is required – but nothing about rate limits, caching, or freshness, so it stays at the baseline band.

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, zero filler, with the core return value front-loaded before the access note. 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 parameterless lookup with no output schema, the description tells the agent what comes back (destination and dial code) plus the no-auth constraint, and annotations cover safety. Only the routing gap versus similar number-related siblings keeps it just short of full completeness.

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

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

The schema has zero parameters, and the rubric sets a baseline of 4 for parameterless tools. There is no parameter surface for the description to clarify, so this dimension is essentially satisfied by definition.

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

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

States a specific verb ('Returns') and resource ('UK shared Always-forward destination and the dial code'), which is distinct enough to identify the output. It does not explicitly distinguish itself from similar siblings like get_forwarding or quote_number, so it does not reach the top band.

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 only usage-flavored note is 'No sign-in', which is really an access trait moved into behavioral territory. There is no guidance on when to use this versus get_forwarding, quote_number, or search_numbers, and no 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?

Annotations already declare a non-read, non-destructive, non-idempotent, closed-world mutation. The description goes beyond them by disclosing the empty-value stop behavior and the 'verified number' and 'Pro plan' preconditions, which are not in the structured data. It stops short of describing reversibility or failure modes.

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 front-loaded sentences with no filler; the mutation behavior comes first and the plan constraint is a compact trailing note. Every clause carries information.

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

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

With no output schema and two parameters (one undocumented), the description is adequate on the mutation itself but leaves the identity_id target and any return/confirmation behavior unaddressed. Annotations cover the safety profile, so the remaining gaps are moderate rather than severe.

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

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

Schema coverage is 50%: forward_to is documented with the empty-to-stop semantics, which the description reinforces, but identity_id has no description in either the schema or the prose. The description adds meaning for one parameter while leaving the other entirely opaque.

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

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

States a specific verb and resource: pointing a verified number at a business number on this seat, plus the stop behavior. It cleanly separates update_forwarding from its read counterpart but never names get_forwarding or any other sibling, so it is clear without being explicitly differentiated.

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?

Gives a usable condition (pass an empty forward_to to stop) and a plan gate ('Pro plan'), which is real when-to-use guidance. However it never names the read alternative get_forwarding or states prerequisites like number verification requirements beyond the passing mention.

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

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

Annotations already disclose the write/idempotency/safety profile (readOnly=false, idempotent=false, destructive=false). The description adds the 'Business plan' plan-tier requirement, which is useful behavioral context beyond annotations. However, it says nothing about what happens to existing windows on edit, and the 'upsert' wording sits oddly against idempotentHint=false without explanation.

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?

Front-loads the core action well and stays short. But the trailing 'Business plan.' is a cryptic one-word fragment with no verb or explanation, and the day/start/end details are dropped in without connecting them to the 'windows' parameter.

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 4-param mutation tool with no output schema, the description covers the time-format semantics but leaves id, name, timezone, and the nested windows structure largely unexplained, and the plan gating is only alluded to. It is minimally usable but has clear gaps.

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

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

Schema description coverage is 0%, so the description must carry the burden, yet it only illuminates 'day' (0=Monday..6=Sunday), 'start'/'end' (HH:MM) - fields that are not even top-level schema properties but presumably live inside the untyped 'windows' items. The actual parameters id, name, timezone are left undocumented in both schema and 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?

States a specific verb+resource: 'Creates or edits a named weekly schedule.' This is clearly distinguishable from siblings like upsert_menu and upsert_queue, though it doesn't name them explicitly. The purpose is clear despite the terse phrasing.

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 when-to-use, when-not-to-use, or alternative guidance is given. The only usage signal is the fragment 'Business plan.' which hints at a plan prerequisite but is not explained. An agent gets no help choosing this over other upsert_* 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the safety profile is known. The description adds a non-obvious behavioral fact—that an AI receptionist does not transfer a live conversation—which is useful context. However, it omits critical operational details: the upsert semantics (how matching is done, e.g., by id vs name), the effect of leaving fields empty (all parameters are optional), and what happens to existing menu keys on edit.

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 appropriately short (three short sentences) and front-loads the core action. However, the final sentence about AI receptionists and live transfers is tangential and not clearly tied to this tool's parameters or behavior, making the structure feel slightly disjointed rather than fully focused.

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 mutation tool with no output schema, five undocumented parameters, and only partial annotations, the description is incomplete. It does not explain the upsert matching logic, permissions (beyond a vague 'Business plan' mention), or how optional fields interact, so an agent would lack sufficient information to call the tool correctly and predict its effects.

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

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

With 0% schema description coverage and 5 undocumented parameters, the description carries full responsibility, but it only vaguely explains the `keys` parameter ('Each key rings a person or a queue') and ignores `id`, `name`, `enabled`, and `greeting` entirely. It does not clarify that all parameters are optional or describe acceptable formats for key mappings, leaving significant gaps for an agent trying to construct a valid call.

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+resource (creates or edits a press-1 menu), which is clearer than the bare name. However, 'press-1 menu' is a colloquialism that doesn't map cleanly to the tool identifier or distinguish it from sibling tools like upsert_queue or upsert_receptionist. It lacks the standard PBX/IVR terminology that would make its purpose unambiguous to an agent.

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 alternative menu/routing tools such as upsert_queue, upsert_receptionist, or set_number_routing. The note 'A caller can reach a person this way' and 'An AI receptionist does not transfer a live conversation' hints at a distinction but does not state when to prefer one mechanism over another, leaving the agent to infer routing logic.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false. The description adds genuine context beyond them: 'Calls ring only members who are signed in and available' and the Business-plan eligibility gate. It does not explain partial-update behavior (the role of id when editing), what happens to existing members, or any return/result semantics, so it remains partial.

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

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

Three short sentences, front-loaded with the core action, then the behavioral fact, then the plan constraint. No filler. The terse 'Business plan.' fragment is abrupt but does earn its place as a gating condition.

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 mutation tool with 7 undocumented parameters, no output schema, and only partial annotation coverage, the description is too thin. It omits how edits behave, what the strategy/overflow options mean, and any result or side-effect detail an agent would need to invoke it correctly.

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

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

Schema description coverage is 0% across 7 parameters, so the description carries the full burden and largely fails it. 'Queue of people' loosely hints at member_ids and 'edits' hints at id, but name, overflow, strategy, auto_record, and max_wait_seconds are left entirely undocumented, including the semantics of the two enums.

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

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

States a specific verb and resource: 'Creates or edits a queue of people on this account.' The upsert semantics are clear and consistent with the name. It does not differentiate itself from the other upsert_* siblings (upsert_hours, upsert_menu, upsert_receptionist), but the resource itself is 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 explicit when-to-use vs alternatives guidance; it doesn't tell the agent how to choose between this and upsert_receptionist/upsert_menu. The 'Business plan' note is an eligibility prerequisite rather than usage routing, which is useful but not what this dimension asks for.

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

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

Annotations already declare this is a write (readOnlyHint=false), non-destructive, non-idempotent, closed-world operation, so the safety profile is covered. The description adds two useful facts beyond that: the plan gating requirement and the no-live-transfer interaction behavior. It still does not say what editing overwrites or how id/idempotency behaves, so it stays at 3.

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 compact sentences, front-loaded with the action and configured fields. The 'Business plan.' fragment is terse but readable, and nothing is padded.

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 7-parameter mutation with 0% schema coverage and no output schema, the description is too thin: it omits half the parameters (voice, enabled, languages, id) and gives no hint of what the edit overwrites or returns. An agent cannot reliably invoke this without guessing at parameter meaning.

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% across 7 parameters, so the schema documents nothing. The description names only three fields (name, greeting, knowledge) and leaves voice, enabled, languages, and especially id undocumented, so it does not compensate for the coverage gap.

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

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

States a clear verb pair (creates or edits) and resource (AI receptionist), and enumerates what it configures: name, greeting, and knowledge. It is not differentiated from sibling upserts (upsert_hours, upsert_menu, upsert_queue), which an agent must disambiguate by resource name alone.

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 'Business plan' fragment implies a plan prerequisite, and 'does not transfer the live conversation to a person' hints at scope. However, there is no explicit when-to-use versus siblings like control_call or upsert_queue, nor any statement of when this should not be used.

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