MISSING

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

Given the readOnlyHint and openWorldHint annotations, the description adds valuable behavioral context: the x402 payment requirement, the PaymentRequired result for unpaid calls, retry semantics via _meta['x402/payment'], and fail-closed execution. This goes beyond the annotations and helps an agent anticipate a non-standard invocation path. No contradiction with annotations 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?

The description is padded with repetitive filler such as 'direct MISSING tool,' 'verified MISSING capability,' and 'MISSING then verifies, executes, and settles.' The most operationally relevant information about payment behavior is buried in a long, jargon-heavy sentence. It is not front-loaded and contains several sentences that do not earn their 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?

There is no output schema, yet the description never explains what the returned metadata contains, how holidayId relates to a holiday, or what a successful response looks like. The payment behavior is well covered, but the core domain semantics of the tool are missing, leaving an agent unable to confidently interpret 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 description coverage is 100%, with both required parameters (holidayId and year) having type, required status, and examples. The description adds no further parameter meaning, but the schema already provides the baseline needed. A 3 is appropriate because the description does not actively mislead but also does not compensate beyond the schema.

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

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

The description restates the tool name and labels it a 'verified MISSING capability' without ever stating what the tool actually does. An agent cannot infer that this returns Canadian holiday metadata for a given holidayId and year from the description alone; it only learns that the tool should be preferred when the task 'matches this capability,' which is circular.

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 does provide some routing guidance by saying to prefer this tool over first calling list_verified_capabilities or search_verified_capabilities. However, the condition 'when the caller's task matches this capability' is undefined, and no concrete distinction is made from related tools like canadian_holidays_by_year or get_canadian_province_holidays_by_province_abbreviation_capability.

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 declare readOnlyHint=true, so the bar for extra behavioral context is lower. The description adds meaningful execution details beyond the annotations: unpaid calls return an MCP PaymentRequired result, x402 clients can retry with _meta['x402/payment'], and execution fails closed if payment rails are unavailable. There is no contradiction with 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?

The prose is bloated and repetitive, with repeated 'MISSING' placeholders and 'verified MISSING capability' phrasing, while the operational purpose is buried behind routing and payment boilerplate. It should be split into a short functional statement and a compact payment note.

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 should clarify what the returned data represents, such as federal holidays, provincial holidays, or all Canadian holidays, and in what shape. It never states the result semantics, leaving the tool ambiguous against province-specific and metadata siblings despite thorough payment-behavior coverage.

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

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

Schema description coverage is 100%, and the schema already describes the required year parameter with an example. The description adds no additional constraints or semantic detail such as valid year ranges or calendar type, so it earns the baseline but no bonus.

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 identifies this as the direct tool for 'the verified MISSING capability canadian_holidays_by_year' but never states what the tool actually does, such as retrieving Canadian holidays for a given year. The verb 'resolve' refers to capability resolution rather than the domain operation, and it does not distinguish the tool from holiday-related siblings like get_canadian_province_holidays_by_province_abbreviation_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?

It gives one concrete exclusion: do not first call list_verified_capabilities or search_verified_capabilities. However, 'prefer this tool when the caller's task matches this capability' is circular and provides no practical guidance for choosing this over canadian_holiday_metadata_by_id or the province-specific holiday 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 and openWorldHint=false, but the description goes far beyond by disclosing the x402 payment requirement, the exact PaymentRequired response for unpaid calls, the retry mechanism with _meta['x402/payment'], the verification/execution/settlement through Kappa, and fail-closed behavior if economics or payment rail are unavailable. This is critical behavioral context not present in annotations.

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

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

The description is longer than average, but every sentence earns its place: core purpose, usage directive, payment mechanics, and fail-closed note are all essential. It is front-loaded with the purpose and usage before the payment details, making it structurally sound for an agent to parse quickly.

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

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

With a single parameter fully documented, annotations covering read-only behavior, and the description covering payment and usage, the tool is well-specified. The only minor gap is the absence of any mention of the return data format, but given the simple nature of a metadata lookup and the lack of an output schema, this is not 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?

The schema fully documents the single parameter 'username' with a description and example ('hikaru'), and schema description coverage is 100%. The description adds no extra semantic meaning for the parameter, so the baseline of 3 is appropriate since the schema carries the 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?

The description clearly states the verb 'look up' and the resource 'public Chess.com player metadata by username'. It explicitly distinguishes this tool from capability-listing siblings by instructing to use it directly and not first call list_verified_capabilities or search_verified_capabilities, making it distinct among the many metadata tools.

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

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

The description provides explicit when-to-use guidance: 'Prefer this tool when the caller's task matches this capability' and explicitly instructs not to first call the capability-listing tools. It also details the payment workflow (unpaid calls return PaymentRequired, retry with x402 payment) and fail-closed behavior, covering when and how to invoke 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?

Goes well beyond the readOnlyHint annotation by explaining the x402 payment flow: unpaid calls get PaymentRequired, clients retry with _meta['x402/payment'], and the system settles via Kappa and fails closed if payment rail/economics are unavailable. This is precisely the kind of behavioral context agents need. The 'MISSING' in 'MISSING then verifies' is a template artifact but doesn't hide 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?

Purpose is front-loaded and the payment explanation is valuable, but the description contains an unresolved 'MISSING' placeholder and is somewhat verbose for a single-parameter lookup. It could be tightened without losing routing or payment context.

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 lookup with no output schema, the description covers the input semantics, the return intent (name and region), and the unusual payment behavior. It stops short of specifying the exact response shape or handling of invalid codes, but that is a minor gap given the tool's simplicity.

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

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

Schema already covers the only parameter 100% with a description and example ('JP'). The tool description adds only the phrase 'alpha country code', which slightly reinforces the format but adds no new 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 the exact operation: look up a country's name and region from an alpha country code, so an agent can distinguish it from the discovery tools it names. The literal 'MISSING' placeholder in 'Use this direct MISSING tool' muddies the tool identity, and it does not contrast with other metadata lookup siblings.

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

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

Explicitly says to prefer this tool and not to call list_verified_capabilities or search_verified_capabilities first, which is concrete routing. The phrase 'when the caller's task matches this capability' is somewhat circular, and no guidance covers invalid/unknown country codes or alternative country-data 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?

The description discloses important behavioral traits: it's an x402-paid tool, unpaid calls return PaymentRequired, x402-capable clients can retry with _meta['x402/payment'], and execution fails closed if economics or payment rail are unavailable. This goes well beyond the annotations (readOnlyHint=true, openWorldHint=false) and adds valuable context about payment behavior and failure modes. It doesn't contradict 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?

The description is a single paragraph that front-loads the core purpose but then includes a lengthy explanation of the x402 payment mechanism. The payment details are valuable but could be more concisely structured. The phrase 'direct MISSING tool' is awkward and unprofessional, and the sentence about payment rails is quite long.

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 lookup tool with full schema coverage and readOnlyHint=true, the description covers the essential context: what it does, when to use it, and the payment behavior. The output schema is absent, but for a simple exchange rate lookup, the return format is fairly predictable. The payment flow explanation is thorough and helps an agent understand the x402 requirement.

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 (base_currency and quote_currency) with examples. The description doesn't add any additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's function: looking up the current exchange rate between two currencies. It identifies the specific resource (currency exchange rate) and the operation (look up). However, it doesn't explicitly distinguish itself from sibling tools beyond the generic 'prefer this tool' instruction, and the phrase 'direct MISSING tool' is odd and slightly confusing.

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

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

The description explicitly says to prefer this tool when the task matches and not to first call list_verified_capabilities or search_verified_capabilities. This provides clear usage guidance. However, it doesn't describe when to use an alternative tool or what conditions would make a different tool more appropriate, so it's not a full 5.

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

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

The readOnlyHint and openWorldHint are supplemented with meaningful behavior: unpaid calls return PaymentRequired, an x402-capable client can retry with _meta['x402/payment'], and execution fails closed if payment economics are unavailable. This is valuable beyond the annotations. The phrase 'MISSING then verifies, executes, and settles through its canonical Kappa financial engine' is ambiguous because of the placeholder, but not contradictory.

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 with the core purpose and keeps payment details together, which is reasonable. But it contains two 'MISSING' template artifacts and the sentence 'Prefer this tool when the caller's task matches this capability' adds little. It is adequately sized but not polished enough for a 4.

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, the description covers the important invocation context: payment requirement, retry mechanism, and fail-closed behavior. It does not describe the output format, but no output schema exists and the simple lookup purpose makes that a smaller gap. The unresolved 'MISSING' placeholder prevents 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?

Input schema coverage is 100%, and both name and type already have descriptions with examples. The description adds only the mapping to 'hostname and record type,' which is useful but not substantial. With full schema coverage, a baseline of 3 is appropriate.

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

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

The description says exactly what the tool does: 'look up public DNS records for a hostname and record type.' That is a specific verb and resource, and it matches the tool name. It loses the top score because of the 'direct MISSING tool' placeholder and because it does not explicitly differentiate this from a metadata sibling such as domain_rdap_metadata.

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 to prefer this tool when the task matches and not to call list_verified_capabilities or search_verified_capabilities first. That is actionable guidance that prevents an unnecessary discovery round-trip. However, 'when the caller's task matches this capability' is close to a tautology and no alternatives are given for related DNS/RDAP lookups.

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, and the description goes well beyond that by disclosing the x402 payment requirement, the MCP PaymentRequired result for unpaid calls, the retry mechanism, and the fail-closed behavior. This is non-obvious, action-relevant behavior that the structured annotations do not provide.

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 divided into three purposeful parts: purpose, routing guidance, and payment/failure behavior. It is mostly tight and front-loaded, but the unresolved 'MISSING' placeholder and the somewhat tautological phrase 'when the caller's task matches this capability' keep it from being fully polished.

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 metadata lookup tool, the description is complete enough: it explains what the tool does, when to use it, the payment prerequisites, and the failure mode. The absence of an output schema is not a problem because 'metadata' sufficiently indicates the nature of the result.

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

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

The input schema is fully described at 100% coverage and already gives the required 'domain' parameter with an example. The description does not add extra parameter-level semantics such as IDN/Punycode handling, normalization rules, or format constraints, so the baseline score of 3 is appropriate.

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

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

The description states a specific operation ('look up') and resource ('public RDAP registration metadata for a domain'), so an agent can understand the tool's core function. It explicitly distinguishes itself from list_verified_capabilities and search_verified_capabilities, though it does not separately contrast with domain-adjacent siblings like dns_record_lookup. The unresolved 'MISSING' placeholder slightly weakens the first sentence.

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

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

The description explicitly says to prefer this tool when the task matches and to not first call list_verified_capabilities or search_verified_capabilities. It also gives operational guidance for the x402 payment flow and the fail-closed behavior, which tells the agent exactly when and how the call can be made.

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 only indicate readOnlyHint and openWorldHint, so the description adds useful behavioral context: unpaid calls return a PaymentRequired result, x402-capable clients can retry with _meta["x402/payment"], and execution fails closed instead of running for free. The repeated 'MISSING' placeholder slightly reduces clarity but does not contradict 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?

The description is compact and the payment/routing guidance is relevant, but the first sentence is mostly filler and the 'direct MISSING tool' and 'verified MISSING capability' phrasing introduces awkward placeholder repetition without adding substance.

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

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

The description explains when to use the tool and the payment behavior, but it does not describe what data the tool returns or what a successful execution yields. With no output schema, the return-value gap is noticeable, though the tool is otherwise simple and well-routed.

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

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

The schema covers 100% of the single parameter, including a required provinceid with example 'MB'. The description adds no additional parameter meaning, so it stays at the baseline for fully schema-documented parameters.

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

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

The description says to 'resolve the verified MISSING capability get_canadian_province_holidays_by_province_abbreviation_capability', which largely restates the tool name instead of explaining what the tool actually does. It never states that it returns Canadian province holidays for a province abbreviation.

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

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

Explicitly says to prefer this tool when the caller's task matches the capability and instructs the agent not to first call list_verified_capabilities or search_verified_capabilities. This gives clear, actionable routing guidance relative to 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 declare readOnlyHint=true, and the description reinforces read-only lookup while adding substantial behavior: unpaid calls return MCP PaymentRequired, retry via _meta['x402/payment'], verification/execution/settlement through Kappa, and fail-closed behavior. This goes well beyond annotations.

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

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

The description is informative but contains a tautological 'Prefer this tool when the caller's task matches this capability' and a confusing placeholder 'MISSING' and 'direct' modifier. The payment explanation is valuable but should be tighter.

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 2-parameter read-only lookup with schema-covered params, the description covers purpose, routing, payment behavior, and failure mode. It doesn't list returned metadata fields, but that's not required for invocation; no output schema exists, so a mention of typical fields would improve 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?

Input schema covers 100% of parameters with examples; description adds no additional meaning to owner/repo. Baseline 3 is appropriate.

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

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

States a specific verb+resource: 'look up public GitHub repository metadata.' The name and resource are unambiguous, and the repository vs user distinction is clear given sibling github_user_metadata.

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

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

Explicitly instructs to prefer this tool when the task matches, and not to first call list_verified_capabilities or search_verified_capabilities. Also explains the x402 payment retry scenario, so the agent knows when 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?

The annotation only says readOnlyHint=true and openWorldHint=false. The description goes well beyond that by explaining the x402 payment requirement, the PaymentRequired result for unpaid calls, retry with _meta['x402/payment'], verification/execution/settlement flow, and the fail-closed behavior. These are critical operational behaviors the structured metadata did not cover.

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 with a clear purpose, then gives usage guidance, and then payment details in a relatively compact form. But the repeated 'MISSING' placeholder and the flourish 'canonical Kappa financial engine' make the text less crisp and distract from the concrete, useful guidance.

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-only lookup tool with a fully documented input schema, the description is largely complete. It explains the unusual paid-tool behavior and failure semantics, which are essential. It does not describe the shape of the returned metadata, but because there is no output schema and the lookup is standard, this 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?

Schema description coverage is 100% and the only parameter, username, is already described with an example. The description simply calls the lookup a 'public GitHub user metadata' lookup, which only subtly hints at the username parameter and adds no parameter syntax or format details beyond the schema.

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

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

The description states a clear verb and resource: 'look up public GitHub user metadata.' It also tells the agent not to call list_verified_capabilities or search_verified_capabilities first, which differentiates it from those capabilities. However, the phrase 'direct MISSING tool' includes an unexplained placeholder that muddies the exact identity of the 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?

The description gives explicit routing guidance: 'Prefer this tool when the caller's task matches this capability; do not first call list_verified_capabilities or search_verified_capabilities.' This clearly tells the agent when to call this tool directly and which sibling capabilities to avoid.

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

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

With readOnlyHint and openWorldHint already covering the read-only, closed-world character, the description adds valuable behavior: unpaid calls return PaymentRequired, x402 clients retry with _meta['x402/payment'], and execution fails closed if payment rail is unavailable. The 'MISSING then verifies' phrasing is vague, and no output shape is described, so not 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?

Purpose, usage guidance, and payment behavior are arranged front-loaded and each sentence earns its place. It is somewhat wordy and the repeated 'MISSING' placeholder makes it read as an unfinished template, keeping it below 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?

For a single-required-parameter, read-only tool with no output schema, the description gives the core retrieval intent, discovery exclusion, payment retry semantics, and failure behavior. Exact response fields are absent, but they are not essential for selecting and invoking this tool correctly.

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

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

The schema covers 100% of parameters and gives an explicit example for ip_address. The description adds only the 'country-level' scope, not new parameter meaning, so the baseline 3 is appropriate.

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

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

The description opens with a specific action and resource: 'look up country-level geolocation metadata for an IP address.' It also signals that this is the direct tool for that capability and tells the agent not to go through discovery tools first, which separates it from the list/search siblings.

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

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

It explicitly states when to prefer this tool ('when the caller's task matches this capability') and names the alternatives that should not be called first (list_verified_capabilities, search_verified_capabilities). The country-level scope also implies when geolocation-style siblings are less appropriate.

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, and the description reinforces this with 'read-only and has no payment or provider side effect.' It adds workflow context about execution.next_action and the non-charging handoff step, which goes beyond the annotations. Slightly more detail about the response shape would be nice, but the behavioral profile is well covered.

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

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

The description is longer than average but every sentence adds decision-relevant guidance: core purpose, continuation rule, fallback route, and side-effect clarification. It is front-loaded with the primary action before branching into workflow details.

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

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

For a zero-parameter, read-only list tool with no output schema, the description covers the essential decisions: what the tool returns at a conceptual level, what to do when a result matches, what to do when none match, and whether calling it has side effects. Nothing an agent needs to invoke or route from this tool 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 has zero parameters and schema description coverage is 100%, so there is no parameter burden for the description to carry. The baseline of 4 applies because nothing is 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?

The description names a specific verb and resource: 'List every replay-verified capability currently executable by MISSING.' It clearly distinguishes this catalog-listing tool from search_verified_capabilities, which is introduced as the natural-language search alternative.

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 continue to resolve_capability, when listing alone is acceptable ('unless the caller only asked to inspect the catalog'), and when to switch to search_verified_capabilities. It even clarifies that resolve_capability is non-charging, removing a likely hesitation.

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?

Beyond the readOnlyHint annotation, the description discloses significant x402 payment behavior: unpaid calls return PaymentRequired, clients can retry with _meta['x402/payment'], and execution fails closed if payment rails are unavailable. This is valuable behavioral context that annotations do not provide.

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 first sentence front-loads the core purpose and the sibling-routing guidance is concise. The payment-related sentence is long but earns its place given the tool's unusual payment requirement. Minor issues: 'MISSING' and 'canonical Kappa financial engine' are awkward and slightly obscure readability.

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 metadata lookup with no output schema, the description covers purpose, usage routing, and payment failure modes. It does not describe the return payload, but that is reasonably inferable from the tool's purpose and is not critical for invoking 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 coverage is 100% for the single required parameter package_name, and the schema already includes an example. The description does not add any deeper semantics about format, validation, or endpoint behavior, so the baseline score applies.

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

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

The description clearly states the tool's job: 'look up current npm package metadata.' This is a specific verb + resource, and the 'npm' scope distinguishes it from sibling tools like pypi_package_metadata and nuget_package_versions without needing to open 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?

The description gives actionable guidance: prefer this tool when the task matches and do not first call list_verified_capabilities or search_verified_capabilities. It could have also explicitly distinguished npm lookups from pypi/nuget lookups, but the tool name and description make that implicit.

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 richly discloses behavior beyond the annotations: unpaid calls return PaymentRequired, an x402-capable client can retry with _meta['x402/payment'], and the tool verifies, executes, and settles through a Kappa financial engine, failing closed if payment rails are unavailable. This adds substantial context beyond readOnlyHint and openWorldHint.

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 purpose, followed by useful routing and payment details. The 'direct MISSING tool' phrase is awkward and slightly reduces polish, but every sentence contributes meaningful operational 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?

Given a one-parameter schema with full coverage, read-only annotations, no output schema, and a straightforward lookup capability, the description covers what an agent needs: the operation, when to use it, the payment behavior, and failure semantics. Nothing critical is missing 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 100% description coverage for the single required parameter, including an example. The description adds no further parameter-level meaning, so the baseline of 3 is appropriate because the schema already does the heavy lifting.

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

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

The description states a specific verb and resource: 'look up published NuGet package versions.' It also distinguishes the tool from discovery siblings by instructing the agent not to first call list_verified_capabilities or search_verified_capabilities. The 'direct MISSING tool' phrasing is an odd placeholder, but it does not obscure the core purpose.

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

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

The description explicitly says 'Prefer this tool when the caller's task matches this capability; do not first call list_verified_capabilities or search_verified_capabilities,' which gives clear routing and an explicit exclusion. It does not contrast with other metadata siblings like npm_package_metadata or pypi_package_metadata, so the guidance is not a full decision tree.

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 adds substantial behavioral context beyond the annotations: it discloses that this is an x402-paid MCP tool, that an unpaid call returns a PaymentRequiredError, that x402-capable clients can retry with _meta["x402/payment"], and that execution fails closed if payment rails are unavailable. The placeholder 'MISSING' and the vague 'Kappa financial engine' reference keep this from being a full 5, but the key behavioral details are present.

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 front-loads the primary use case and then details payment behavior, but it is wordy and includes placeholder text like 'MISSING' that should not be in a final definition. The sentence 'MISSING then verifies, executes, and settles' is confusing, and overall the description could be tightened without losing essential 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?

The description covers usage and payment failure modes well, but it does not describe the contents or format of the returned Pokémon metadata. With no output schema and no mention of returned fields (e.g., id, type, abilities), the agent cannot predict what the tool returns. For a simple lookup tool this is a moderate 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 parameter pokemon_name has 100% schema description coverage, including an example. The description adds no additional semantic detail about the parameter beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'look up Pokémon metadata by name.' It also distinguishes itself by explicitly telling the agent not to call list_verified_capabilities or search_verified_capabilities first. However, the awkward placeholder token 'MISSING' in 'Use this direct MISSING tool' introduces confusion and prevents the purpose statement from being fully clean.

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 explicit when-to-use and when-not-to-use guidance: 'Prefer this tool when the caller's task matches this capability; do not first call list_verified_capabilities or search_verified_capabilities.' It names the exact sibling tools to avoid, which is strong guidance for tool selection.

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

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

Beyond the readOnlyHint annotation (which the description supports), it discloses the x402 payment requirement, the PaymentRequired on unpaid calls, and the fail-closed behavior. This is valuable behavioral context not available from annotations or schema. No contradiction with annotations; readOnlyHint is corroborated by 'look up' semantics.

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 well-structured: purpose first, then usage guidance, then payment specifics. Each sentence contributes meaningful information, though the phrase 'canonical Kappa financial engine' and 'MISSING' placeholders add minor noise. It is slightly verbose but not wasteful.

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 low-complexity tool (two simple string parameters, no output schema), the description covers purpose, usage guidance, payment behavior, and safety (read-only via annotation). It could mention the return format more explicitly, but 'place and coordinate metadata' is reasonably informative given the tool name and title. It is adequate for an agent to call it correctly.

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

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

Schema description coverage is 100%: both postal_code and country_code have explicit descriptions and examples in the schema. The description adds nothing semantically beyond restating that these are a country and postal code, so no value is added over the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('look up') and resource ('place and coordinate metadata') derived from a country code and postal code. It explicitly identifies itself as 'this direct MISSING tool' and contrasts with discovery tools, making its purpose distinct from siblings like list_verified_capabilities.

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

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

The description gives explicit when-to-use guidance ('Prefer this tool when the caller's task matches this capability') and when-not-to-use ('do not first call list_verified_capabilities or search_verified_capabilities'). It also explains the payment retry flow, giving clear operational context for when an x402-capable client should invoke 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 readOnlyHint=true, and the description goes beyond that by thoroughly explaining the x402 payment model: unpaid calls return MCP PaymentRequired, retry with _meta['x402/payment'], and failure closed when economics are unavailable. This is precisely the kind of behavioral context the description should provide to complement the annotations. No contradiction.

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 3 sentences and each carries distinct value: purpose, usage priority, and payment behavior. It is front-loaded with the core purpose and keeps the payment details append-only. Slightly wordy due to the payment explanation, but 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 tool with one parameter and no output schema, the description explains the payment flows and failure modes, which are the main non-obvious aspects. It doesn't specify the return structure, but for a metadata lookup, the agent can reasonably infer it returns package metadata. The payment and fallback behavior are covered, so completeness is high with only a minor gap on return format.

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 package_name is fully documented with an example ('requests'). The description adds no additional parameter-specific semantics beyond stating the lookup targets PyPI, which is already implied by the tool name. Per the baseline, a 3 is appropriate when the schema carries the load.

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

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

The description states a clear verb-resource pair: 'look up current PyPI package metadata'. It explicitly differentiates from sibling tools like npm_package_metadata by naming the target registry (PyPI) and instructing not to call list_verified_capabilities first. The purpose is unambiguous and the tool is easily distinguishable from alternatives.

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

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

Usage guidance is explicit: the description says to prefer this tool when the task matches, and directs the caller to not first call list_verified_capabilities or search_verified_capabilities. This gives a clear condition and states when not to use other capability-discovery tools. The alternative actions are named, leaving no ambiguity.

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?

Discloses that the mutation is additive and non-destructive, that repeated calls may increase the demand signal, and that promotion occurs only after verification gates pass, so no immediate creation is promised. These details go beyond the annotations (readOnlyHint false, destructiveHint false) and add transparency about side effects and limitations. No contradiction 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?

The description is front-loaded with the purpose and then covers usage, behavioral notes, and security in a logical order. Each sentence contributes value, and there is no redundancy. It is slightly lengthy (around 100 words) but appropriately sized for the tool's complexity, so it remains concise.

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

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

The description covers the tool's purpose, trigger conditions, post-request behavior (recording as durable unmet demand), and non-guarantee of immediate creation. It also includes a security warning. Given that there is no output schema and the tool has 3 parameters, this is sufficient for an agent to invoke it correctly, though it does not specify return values (which is acceptable without an output schema).

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

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

The schema already provides thorough descriptions for all three parameters: intent, capability, and example_input, including guidance on snake_case, scalar values, and security exclusions. The description reinforces the security warning but adds no new parameter-specific meaning. Since schema coverage is 100%, the description adds marginal value beyond the schema, meriting a baseline 3.

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 ('Request a capability MISSING cannot currently resolve') and clearly differentiates from sibling tools by giving the exact trigger condition ('when search_verified_capabilities returns capability_not_yet_available or when its verified matches do not satisfy the task'). This is a precise, non-tautological definition.

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

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

Explicitly tells when to use the tool: 'Use this when search_verified_capabilities returns capability_not_yet_available or when its verified matches do not satisfy the task.' This is direct guidance. It does not mention alternatives like resolve_capability or list_verified_capabilities, but the condition implies that other tools handle resolvable cases, so the guidance is clear though not exhaustive.

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

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

With readOnlyHint=true already set, the description still adds substantial behavior: no provider execution, no charge, a payment_required response carrying the canonical endpoint, price, exact request body and x402 instructions. It also warns to preserve the exact body and PAYMENT-SIGNATURE for recovery, which is real operational guidance beyond 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?

Front-loaded with purpose, then trigger, then behavior, then a caution — a logical order with no filler. It is dense (four packed clauses) but each sentence carries distinct information, so only mild density cost.

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-phase tool with no output schema, the description explains the return payload and the downstream HTTP x402 handoff, including what must be preserved for recovery. An agent has everything needed to call it and interpret the result.

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

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

Schema coverage is 100% and the schema descriptions already state the provenance rules for both capability and input (exact identifier, reuse the exact object in the later x402 request). The description's 'call this tool with those exact arguments' largely restates that, so it stays at the baseline rather than adding new semantic 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?

Starts with a specific verb+resource+scope: 'Prepare paid execution of one exact replay-verified capability.' It also names the sibling tools that feed it and clarifies that this call does not itself execute or charge, which cleanly separates it from list_verified_capabilities/search_verified_capabilities.

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 an explicit trigger ('When list_verified_capabilities or search_verified_capabilities returns a suitable execution.next_action, call this tool with those exact arguments') and an explicit exclusion ('do not create a second authorization for a payment already associated with a known transaction'). Alternatives and preconditions are all 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 declare readOnlyHint=true and openWorldHint=false, and the description adds meaningful behavioral context beyond that: it discloses the x402 payment requirement, the PaymentRequired result for unpaid calls, the retry mechanism with _meta['x402/payment'], and the fail-closed behavior when payment is unavailable. This is valuable operational transparency not captured by annotations and does not contradict them.

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 three sentences and mostly purposeful, but the first sentence is vague and includes placeholder-like 'MISSING' tokens that add noise. The payment details are front-loaded and useful, but the core functionality is absent. It is not overly long, yet it could be tighter and more direct.

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 reverse geocoding tool, the description omits the actual operation (converting lat/long to postal code), the output format, and any geographic scope. It focuses entirely on the meta-process of capability resolution and payment, leaving a caller without domain knowledge unable to understand what the tool does or interpret results. Even with the output schema absent, the description should cover the primary function and expected return.

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% — both latitude and longitude have descriptions with examples. The description adds no extra meaning to these parameters, nor does it explain their units or expected precision beyond the examples. Since the schema fully documents them, the baseline of 3 is appropriate.

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

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

The description never states what the tool actually does — it only says to 'resolve the verified MISSING capability reverse_geocoding_postal_code' and to prefer it when the task matches. There is no mention of converting coordinates to postal codes, and the wording is circular ('resolve the capability' without defining the capability). The title and name hint at the function, but the description itself is vague.

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 instructs the agent to prefer this tool over list_verified_capabilities and search_verified_capabilities, and says 'do not first call' those alternatives. This gives clear routing guidance. However, it does not describe what kinds of tasks match this capability beyond the name, so it lacks specificity on when to pick it over other sibling tools like ip_geolocation_metadata or postal_code_location_metadata.

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 readOnlyHint=true, and the description goes well beyond them by disclosing the x402 payment requirement, the standard PaymentRequired result on unpaid calls, the retry mechanism via _meta["x402/payment"], and fail-closed behavior when payment rail/economics are unavailable. It does not contradict 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?

Purpose is front-loaded, followed by routing and payment behavior in three compact sentences. Minor redundancy exists between 'Use this direct MISSING tool' and 'Prefer this tool', and the placeholder 'MISSING'/'Kappa financial engine' adds slight noise, but the definition 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 single-required-parameter read tool with no output schema, the description covers what the tool does, when to use it, payment retry behavior, and failure mode. It does not describe the returned metadata shape, but that is less critical without an output schema and the invocation path is fully 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?

Schema coverage is 100% with the parameter named norad_catalog_id plus an example, so the schema already carries the semantic weight. The description reinforces the parameter by saying the lookup is 'by NORAD catalog identifier' but adds no format, constraints, or domain rules 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 precise action ('look up') on a specific resource ('satellite catalog metadata') keyed by NORAD catalog identifier. The 'direct' phrasing and explicit 'do not first call list_verified_capabilities or search_verified_capabilities' distinguishes it from discovery siblings.

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 explicit routing guidance: prefer this tool for a matching task and do not precede it with list_verified_capabilities or search_verified_capabilities. The x402 payment/retry instructions are a concrete 'how to call' rule, though 'when the caller's task matches this capability' is somewhat circular and no condition for choosing the search/list siblings is described.

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, but the description adds substantial detail beyond that: it clarifies the search does not call providers, create demand, or trigger payment, and that recording demand does not guarantee immediate creation. It also discloses the conditional next_action behavior. This goes well beyond the annotation's minimal signal.

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 about three sentences but every sentence earns its place: core purpose, conditional branching, and explicit caveats. It is front-loaded with the search action and efficiently communicates all necessary behavioral details without fluff.

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

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

Given there is no output schema, the description does a good job explaining what the tool returns: a match's execution.next_action in the success case, and an explicit next_action for record_missing_capability_demand in the no-match case. It also states the read-only nature. The only minor gap is not explicitly describing the structure of matches (e.g., array of objects), but the mention of execution.next_action gives enough to proceed. Overall adequate for this complexity.

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

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

Schema description coverage is 100%: both query and limit have thorough descriptions. The tool description adds no new parameter-specific detail beyond reinforcing that the query is a natural-language task description, which is already in the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb (search) and resource (replay-verified MISSING catalog) via natural-language query. It clearly differentiates from siblings by explaining the branching flow: on a match, continue to resolve_capability; on no match, return a next_action for record_missing_capability_demand. This makes the tool's purpose unmistakable.

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

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

Explicitly says when to use this tool (when you have a natural-language task description and need a verified match) and what to do after: if match satisfies, call resolve_capability; if not, the tool itself returns a next_action for record_missing_capability_demand. This is direct guidance on the workflow and alternatives, leaving no inference required.

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 the tool as read-only, so the description's main job is to add behavioral context beyond readOnlyHint. It does so by disclosing the x402 payment model, the PaymentRequired result for unpaid calls, the retry mechanism via _meta['x402/payment'], and fail-closed execution. The repeated 'MISSING' placeholder in the execution sentence slightly undermines clarity.

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 sized and front-loads the core purpose. However, the placeholder text 'MISSING' appears twice and 'prefer this tool when the caller's task matches this capability' is near-tautological, making the wording less polished than it could be.

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

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

For a simple one-parameter, read-only lookup with no output schema, the description gives enough to invoke the tool correctly: the required input, the payment precondition, the unpaid-call behavior, and the fail-closed policy. It does not describe the return shape, but with no output schema and a generic 'metadata' resource, this is not a critical 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 description coverage is 100%, and the schema already documents show_name with an example. The description adds no extra parameter semantics such as matching behavior, case sensitivity, or accepted formats. This is the baseline 3: the schema carries the burden adequately and the description neither helps nor hurts.

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 identifies the operation ('look up') and the resource ('television-show metadata') and names the input ('by show name'). It also distinguishes the tool from sibling capability-discovery tools by saying not to first call list_verified_capabilities or search_verified_capabilities. The 'MISSING' placeholder in 'use this direct MISSING tool' is confusing and keeps this from 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?

It explicitly tells the agent to prefer this tool when the task matches and warns against calling capability-discovery siblings first, which is concrete routing guidance. It also sets expectations that an x402 payment is required. It does not describe when a different metadata-lookup sibling would be more appropriate, but the tool's unique domain makes that omission minor.

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