SqueezeOS — Institutional AI Market Intelligence

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

Even though annotations already declare openWorldHint true and readOnly false, the description adds critical behavioral detail: unsigned calls return a live x402 challenge, never auto-spend, and require a challenge-specific payment_signature to proceed. This goes beyond the annotations by explaining the payment negotiation flow and the meaning of the payment_signature parameter.

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 dense sentences, zero filler. The primary function is stated first, followed by the payment flow caveat. Every word earns its place, and the critical behavioral nuance is not buried.

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 3-parameter tool with no output schema, the description conveys the essential invocation flow: URL in, Markdown out, optional max_chars, and the payment challenge handshake. It does not enumerate error cases or exact response schema, but the description provides enough to attempt a correct first 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 67%: url and payment_signature have descriptions, while max_chars does not. The main description adds context for payment_signature ('challenge-specific') but does not clarify max_chars beyond the schema's absence. This is adequate but not exceptional; the schema and description together cover most parameter meaning.

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

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

The description states a specific action (give one public HTTPS URL, receive Markdown) and a specific resource (public HTTPS URLs via Clean Web Reader). It clearly differentiates the tool from the sibling capability and x402 tools, which are about metadata/contracts rather than fetching web content.

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 makes usage context clear: use this tool to read a public HTTPS URL into LLM-ready Markdown without an SML account. It also provides procedural guidance for the x402 flow (unsigned call first, then retry with a challenge-specific signature). It does not explicitly name alternatives or when-not-to-use, but that is not needed given sibling differentiation.

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

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

The description carries the safety burden since annotations are open-ended: it discloses write gating, the 402 fallback behavior, and the payment-signature retry rule. It also explicitly states the access boundary for sensitive routes and auth headers.

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?

Four sentences, front-loaded with the core action, with no filler. Every sentence contributes operative detail: read/wrote semantics, fallback, retry, and access restrictions.

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?

Covers the main input rules, 402 handling, retry policy, and exclusions, enabling safe invocation. A modest gap remains because there is no explicit normal success-return format or non-402 error behavior, and no output schema exists.

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?

Adds meaning beyond schema for method, confirm_write, payment_signature, and alternative_intent. Schema covers path/payment_signature/alternative_intent, but body and query remain undocumented; still the critical invocation flow is clarified.

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 action ('Call'), resource ('concrete SqueezeOS REST path'), and host ('canonical public host'), with clear scoping that sensitive operator/control routes are not exposed. This distinguishes it from sibling discovery/manifest tools as the execution tool.

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

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

Gives clear context: GET is read-only, POST requieres confirm_write=true, and 402 without payment_signature triggers an SML fallback with rety only on challenge-specific signature. It implies the selection vs siblings but doesn't explicitly name alternatives like discover_capabilities.

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, and destructiveHint=false, so the safety profile is covered. The description adds useful context that the manifest is dynamically generated from the Flask route table and is the canonical authority, but it does not disclose return format, structure, or content details, which would add further behavioral transparency.

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

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

Two concise sentences with no filler. The primary action and resource are front-loaded in the first sentence, and the second sentence establishes the tool's authoritative role without wasting words.

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

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

For a zero-parameter, read-only manifest tool, the description provides enough to invoke the tool correctly and understand its purpose. However, since there is no output schema, a bit more detail about the manifest's shape or contents would make the tool fully self-explanatory, and the sibling differentiation could be more explicit.

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

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

There are no parameters, and the input schema is an empty object with 100% schema description coverage. With zero parameters, the description does not need to explain parameter semantics; the baseline of 4 applies because there is nothing to define.

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

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

The description uses a specific verb ('Return') with a clearly identified resource ('current machine capability manifest') and even names its source ('running Flask route table'). The phrase 'canonical product-inventory authority for MCP discovery' helps distinguish it from sibling tools like discover_capabilities and inspect_capability by positioning it as the authoritative manifest source.

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

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

The description implies when to use the tool: when one needs the current, authoritative capability manifest for MCP discovery. It does not explicitly contrast it with sibling tools or state when not to use it, so it stops short of full routing guidance, but the context is clear enough for a zero-parameter read-only operation.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the bar is lower. The description adds useful behavioral context beyond annotations: it emphasizes that results come from real live metadata and that no fabricated composite score will be generated. This clarifies what the tool will and will not report.

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 one tightly packed sentence that front-loads the action and scope, then adds a meaningful contrast. No filler or redundancy exists; every clause contributes to selection and invocation understanding.

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

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

The core purpose and key boundary ('no composite score') are clear, but with no output schema the description should better indicate what the returned comparison looks like. It also omits any detail about the probe parameter. An agent can select the tool confidently, but may still be uncertain about invocation behavior and output shape.

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 compensate for parameter meaning. It only weakly implies sml_ids via '2-5 capabilities,' but does not explain that sml_ids are the identifiers being compared. The 'probe' boolean parameter, which defaults to true, is completely unexplained, leaving its behavioral impact ambiguous.

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 ('compare'), a bounded resource ('2-5 live capabilities'), and a concrete data source ('real metadata returned by inspect_capability'). It also distinguishes itself from score-producing tools with 'no fabricated composite score is produced.' This clearly differentiates it from siblings like inspect_capability and recommend_capability.

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

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

The description gives clear context: use this when you need a multi-capability comparison grounded in the same real metadata as inspect_capability. The negative clause 'no fabricated composite score is produced' implicitly steers away from recommendation-style tools. However, it does not explicitly name when-not-to-use scenarios or alternative sibling tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description adds valuable behavioral context beyond these: lexical mode is guaranteed available, unified mode may add evidence-backed semantic/graph context, and it explicitly promises not to fabricate scores. This gives the agent useful trust and fallback expectations.

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

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

Two front-loaded sentences deliver the purpose and key mode distinction with no filler. Every clause earns its place, and the description stays appropriately compact for 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?

The schema covers parameter constraints and annotations cover safety, but there is no output schema and the description does not describe return shape, score semantics, or fallback behavior when unified mode is unavailable. It is enough to invoke the tool, yet leaves some operational context implicit.

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, the description must compensate for parameter meaning. It meaningfully explains the mode parameter and the distinction between lexical and unified behavior. However, it does not describe query semantics or limit behavior, leaving those to their names and schema constraints.

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, resource, and scope: 'Search the live SqueezeOS capability inventory.' This clearly distinguishes the tool from siblings like inspect_capability, recommend_capability, or call_capability as the discovery/search entry point.

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 use for discovery/searching capabilities and mentions the two available modes, but it does not explicitly state when to prefer discover_capabilities over inspect_capability or recommend_capability, nor when to choose lexical versus unified mode. Some usage context is present, but no exclusions or alternative routing.

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

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

The annotations already establish read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context beyond that: it performs a real liveness probe only when safe, and it explicitly avoids returning an invented reliability score, which is valuable honesty about its execution 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 sentence, front-loaded with the core action and identifier, then the key outputs and a meaningful disclaimer. Every clause earns its place; there is no redundant wording or repetition of schema fields.

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 inspection tool, the description explains the key input, output, and situational caveat. The only minor gap is the vagueness of 'when safe,' but the rich annotations and simple signature keep this from being a significant omission.

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, the description carries the burden of explaining parameters. It clarifies that sml_id selects the capability and that a liveness probe is performed when it is safe, which maps to the probe boolean. It does not explicitly name the probe parameter, but the semantics are sufficiently conveyed.

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

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

The description clearly states the tool inspects one specific live capability identified by sml_id, and names the concrete outputs: endpoint/payment metadata and a real liveness probe. This distinguishes it from broader discovery or comparison tools without requiring schema inspection.

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 intended use is implied: use this when needing details about one specific capability rather than discovering or calling capabilities. However, it does not explicitly say when to prefer this over sibling tools like capability_manifest or discover_capabilities, nor does it state 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?

Annotations already declare this safe/read-only/idempotent, and the description does not contradict that. It adds useful context ('live endpoint/payment metadata', 'next actions') but does not disclose possible side effects, rate limits, or authorization requirements beyond what the annotations capture.

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 states the core purpose and the valuable output extras without repetition or filler.

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

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

With no output schema, the description gives a useful high-level picture of the return payload (capabilities, live metadata, next actions) and both parameters are covered by schema/description together. It stops short of describing output formatting or how matching works, but that is not required for 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?

With 0% schema description coverage, the description adds crucial meaning to the required query parameter by framing it as a natural-language need. It does not elaborate on the optional limit parameter, but its meaning is readily inferable from its name, default, and min/max constraints.

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

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

The description uses a specific verb ('Return') and resource ('real SqueezeOS capabilities') and specifies the input ('natural-language need') and output extras ('live endpoint/payment metadata and next actions'). 'Best matching' distinguishes it from sibling discovery/inspection tools even without naming 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?

It clearly states the context for use: when an agent has a natural-language need and wants the best matching capability. It does not explicitly exclude alternatives such as discover_capabilities or describe when to prefer those, so it stops short of full routing 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 carry the read-only, idempotent, and non-destructive safety profile, so the description only needs to add value beyond that. It adds meaningful behavioral context: the tool is a live passthrough of the SqueezeOS endpoint and deliberately does not synthesize cluster-health or synchronization claims. No contradictions with 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?

Two sentences, with the core verb and resource front-loaded and a valuable caveat presented second. No wasted words or redundant restatement of the schema.

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, read-only status tool with rich annotations, the description is sufficient for an agent to call it correctly. It states what is read and what is not guaranteed, though it could have briefly noted expected response shape since no output schema exists.

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

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

The tool has zero parameters and the schema coverage is effectively 100%, so there is nothing semantic to add. The description correctly implies that no arguments are needed, which is sufficient.

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 and resource: 'Read the live SqueezeOS status endpoint.' The negative caveat about not synthesizing cluster-health or synchronization claims adds scope precision, though it does not explicitly differentiate among sibling tools by name.

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

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

The description implies when to use the tool — when you need raw, live status from the endpoint — and warns against expecting synthesized health/sync claims. However, it does not explicitly state when to prefer it over alternatives or provide exclusion criteria, leaving usage mostly inferred.

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 mark this as read-only, idempotent, non-destructive, and open-world, so the description does not need to restate those. It adds valuable behavioral nuance: the returned contract is canonical but spend terms inside it should not be treated as authoritative, which is exactly the kind of context annotations do not convey.

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

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

The description is two sentences with no filler. The first sentence states the action and object; the second adds a critical caveat that prevents misuse. 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 read-only tool, the description is complete: it names the exact resource, identifies it as the canonical v2 discovery contract, and warns about the authoritative source of spend terms. The remaining details are likely inherent in the contract content itself and are not necessary for correct invocation.

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

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

The input schema has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The tool takes no inputs, and the description appropriately focuses on what it returns rather than on inputs.

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

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

The description uses a specific verb ('Return') and names the exact resource ('the canonical SqueezeOS x402 v2 discovery contract'), which is unambiguous. This clearly differentiates it from sibling tools like x402_evidence and x402_readiness, which concern evidence and readiness rather than the discovery contract itself.

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

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

The description provides important usage context by warning that spend terms are authoritative only in a fresh PAYMENT-REQUIRED challenge, not from this contract. It implies when the tool should be used—when you need the canonical discovery contract—but does not explicitly name alternative tools or state when not to use it.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior, so the bar is lower. The description adds valuable context by emphasizing that only 'real' evidence from the canonical rail is returned and by clarifying the trust boundary around challenges and signatures.

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 concise sentences with no filler. The main action is front-loaded, and the second sentence adds a meaningful caveat that earns its place by preventing misuse.

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

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

For a zero-parameter read-only tool, the description is largely complete: it states what is read, the source, and a key trust qualifier. Since there is no output schema, some detail about the exact shape of the evidence is absent, but this is a minor gap for tool selection and invocation.

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

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

The tool has zero parameters and the input schema is complete, so there are no parameter semantics to document. The description therefore does not need to compensate for any parameter coverage gaps.

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

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

The description clearly states a specific verb ('Read') and a distinct resource ('real settlement evidence recorded by the canonical x402 rail'). It differentiates this tool from siblings like x402_contract and x402_readiness by focusing on evidence rather than contract state or readiness.

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

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

The description provides clear context for when to use this tool: when settlement evidence is needed from the canonical rail. It also adds an important exclusion by stating that a challenge or signature alone is never proof, which helps an agent avoid using this tool inappropriately or misinterpreting its results.

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 establish readOnlyHint=true and idempotentHint=true. The description adds useful behavioral context by saying the surface is 'live' and 'canonical,' implying real-time authoritative data rather than cached or partial information. It does not describe the response structure, but the safety profile is well covered by 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?

A single sentence with no filler. The verb is front-loaded, the resource is specific, and the usage timing is appended without redundancy.

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

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

For a zero-parameter read-only tool, the description provides the purpose, resource, and intended usage context. The only minor gap is that it does not hint at what the readiness response contains or how to interpret it, but this is not necessary for correct invocation.

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

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

The tool has zero parameters, and the empty schema already documents this completely. With no inputs to explain, the description does not need to add parameter semantics, so the baseline of 4 is appropriate.

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

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

The description clearly states the action ('Read') and the resource ('live canonical payment-rail readiness surface'), and adds the timing context 'before attempting a paid call.' This distinguishes it from sibling tools like x402_contract or capability_manifest by focusing specifically on the readiness surface as a preflight check.

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

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

The description explicitly tells the agent when to use this tool: before attempting a paid call. It does not explicitly name alternatives or exclusions, but the use case is clear and sufficient for a zero-parameter readiness check.

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