x402-checks

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

Adds real context beyond the annotations: it discloses the deterministic checksum method, states the limits of what a pass/fail means (cannot confirm the recipient or prevent reversals), and notes it returns a signed XDR-1 receipt. Annotations already cover read-only/idempotent/OpenWorld, so this is a solid supplement.

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 tightly packed sentences, front-loaded with the method and followed by the caveat. Zero filler; every clause carries information an agent needs.

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

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

An output schema exists, so return values need not be explained, and the description covers method, scope, and limitations. The only real gap is the unaddressed duplicate/alias parameters with zero required fields, which an agent must resolve from the schema alone.

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. The description adds nothing about the aliasing between 'routing' and 'aba_routing' or which to supply, leaving that entirely to the schema — 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 verb (validate), a specific resource (US ABA routing number), and even the exact algorithm used ((3,7,1)-weight mod-10 Fedwire/ACH checksum). This clearly separates it from siblings like swift_bic_check, iban_check, or uscc_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?

Gives an explicit usage condition — catch mistyped routing numbers before payment — plus scope exclusions (does not prevent transfer reversals, does not establish the recipient). It stops short of naming which sibling to use instead for identity or reversal concerns, so routing is implied rather than prescribed.

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

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

Annotations already declare readOnly, idempotent and open-world, so the safety profile is covered. The description adds real value beyond them by naming the validation method (mod-89 checksum) and disclosing that a signed XDR-1 receipt is produced, though it does not say what happens when the checksum fails.

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

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

Three short sentences, front-loaded with purpose, then obligation, then output. Nothing is redundant or 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?

Output schema exists so return values needn't be explained, and annotations cover safety; the description supplies purpose, algorithm and use context. The one remaining gap is failure semantics — whether an invalid ABN yields a false result, an error, or a rejected receipt.

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

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

Schema description coverage is 100% and the single `abn` parameter is fully documented in-schema, including spacing rules. The description's "(11 digits)" merely restates the schema rather than adding format or parsing meaning, so baseline 3 applies.

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

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

States a specific verb (Validate), resource (Australian Business Number), and the exact algorithm (mod-89 checksum, 11 digits), which cleanly separates it from siblings like vat_mod97_check or gstin_check that validate other identifier schemes.

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?

"Required before invoice payment to Australian contractors" gives a concrete triggering context for use, but no explicit when-not condition or named alternative for non-Australian vendors (e.g. gulf_supplier_check, china_supplier_check).

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, and the description reinforces this usefully by calling the output 'deterministic' and emphasizing it is advisory and non-custodial ('without uncollateralized lending or float'). However, it does not disclose how the optional history inputs (first_seen_days, settled_calls_90d, sponsor_attestations) are treated when omitted — whether they are fetched on-chain or defaulted — which is exactly what an agent needs to know given the 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?

Two sentences, zero waste, with the core capability stated first and the output shape second. The vocabulary is unusually heavy ('non-custodial unsettled exposure advisory evaluation'), which costs some immediate readability, but nothing is redundant.

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

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

An output schema exists and seven parameters are fully documented, so return values and inputs are covered elsewhere. The remaining gap is the one thing only the description could resolve: whether the caller must supply historical metrics or the tool derives them, given the openWorld annotation and the mostly-optional parameter set with only 'subject' required.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema and the baseline of 3 applies. The description adds nothing at the parameter level; its detail is entirely about output semantics (grade scale, exposure cap), not about how to populate subject, role, or the optional history fields.

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

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

The description names the action and resource concretely: it produces a deterministic trust score for a counterparty agent and returns grade (T0-T3), historical success rate, and a suggested maximum settlement exposure. It clearly is not a generic screening tool like sanctions_address_screen or token_contract_risk, though it never explicitly contrasts itself with those siblings. The dense jargon ('unsettled exposure advisory evaluation') slightly obscures an otherwise distinguishable 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?

Usage is implied rather than stated: 'maximum suggested settlement exposure without uncollateralized lending or float' signals the pre-settlement due-diligence context, but there is no explicit when-to-use, when-not, or named alternative among the many screening siblings. An agent must infer that this is the tool to call before extending credit/settlement exposure to an agent address.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety and repeatability profile is covered. The description adds real value with 'deterministic structural checks', clarifying these are format/checksum validations rather than authoritative registry lookups — an important distinction. However, it never says what happens when all three optional fields are omitted or what a partial check reports.

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

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

Two short sentences with the bundled scope front-loaded and zero wasted prose. The 'one call, one receipt' phrasing is slightly slogan-like but it does communicate consolidation efficiently.

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

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

Output schema and annotations are present, so the description needn't explain return values. The remaining gap is behavioral: with zero required parameters, an agent has no signal about whether an empty call is valid or how a one-field invocation behaves. For a multi-check pack that gap matters.

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 each property already documents itself as optional, so the schema does the heavy lifting. The description lists the same three fields but adds no format hints, no indication of whether at least one is required, and no meaning beyond what the schema provides. Baseline 3 applies.

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

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

The description names a specific resource and scope: a bundled verification covering KRA PIN, IBAN and SWIFT/BIC. An agent can tell this is the consolidated East-Africa pack rather than a single-field check. It stops short of naming the siblings it replaces (kra_pin_check, iban_check, swift_bic_check), so differentiation is implied rather than explicit.

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

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

'One call, one receipt' hints that this is the consolidated option, and 'East African trade corridors' implies the regional context. But there is no statement of when to prefer this over the individual kra_pin_check / iban_check / swift_bic_check tools, and no guidance on partial inputs. Usage is inferable, not specified.

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

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

Annotations already declare readOnlyHint, openWorldHint and idempotentHint, so safety is covered. The description adds genuinely non-derivable behavior: values come back both raw and formatted, and the result carries a signed receipt, which tells the agent the response is attestable.

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

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

Two tight sentences with no filler. Asset scope and default are front-loaded, and the receipt note is appended only because it matters.

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

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

An output schema exists, so return shape need not be explained, and the description covers chain, assets, encoding and the receipt. The one real hole is sibling disambiguation against erc20_balance.

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

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

Schema description coverage is 100%, so both parameters (address, token_address) are already documented, including the USDC default. The description restates the default-token behavior but adds no format or constraint detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource: fetching native ETH and one ERC-20 (default USDC) balance for an address on Base. The scope (chain, asset types, default token) is concrete enough to distinguish it from generic balance readers, though it never names the near-identical sibling erc20_balance.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance. With erc20_balance in the sibling list, an agent has to guess which tool to pick for a single-token query versus this one; the description offers no routing rule.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so safety is covered. The description adds two things beyond structured data: results carry a per-item 'scope' and that batch pricing should be compared against individual quotes - genuine behavioral context, though the latter is vague and never says how to obtain a quote (a check_price sibling exists but is unnamed).

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

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

Two sentences, front-loaded with the capability and its limit, no filler. The long parenthetical type list is partly redundant with the schema enum and costs some density, but it does let an agent decision-check without opening 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?

With an output schema handling return shape and annotations covering read-only/idempotent behavior, the description needs only to explain batching, limits and per-item scope - all present. Missing is any guidance on partial failures or mixed validator batches, and the unexplained 'context-distill' option.

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 each field is documented, so the baseline applies. The description's list of supported identifier families roughly mirrors the enum but omits one enum member, 'context-distill', leaving that option explainable only by the schema; the max-50 limit is likewise already in maxItems.

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

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

States a specific verb and resource (validate identifiers) with a clear scope (up to 50, in one batch request) and enumerates the identifier families covered. The 'in one batch request' framing implicitly separates it from the single-check siblings (iban_check, lei_check, etc.), but it never names them, so an agent must infer the batch-vs-single distinction.

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

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

The phrase 'Compare the current batch quote with individual quotes; savings depend on batch size' hints that this tool competes with per-item calls, but it frames the tradeoff purely in cost terms rather than telling the agent when to pick batch_validate over iban_check or lei_check. No explicit when/when-not, no note on whether a single-item batch is acceptable.

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

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

Annotations already cover read-only and idempotent semantics, and the description adds the non-obvious fact that the result carries a signed receipt. It stops short of explaining what that receipt attests to, whether pending blocks behave differently, or any failure modes — real value, but thin.

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

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

Two sentences, no filler, with the chain identity and field list front-loaded before the receipt note. Every clause carries information an agent could not get from the title alone.

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?

Output schema is present, so return-value detail is unnecessary, and the input is a single documented optional parameter. The only remaining gap is the vague 'signed receipt' reference, whose purpose for the caller is never made actionable.

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 'block' parameter has 100% schema coverage including hex/decimal/tag formats and the 'latest' default, so the schema does the heavy lifting. The description adds nothing beyond 'any block', which is the expected baseline when coverage is high.

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?

Names the specific chain (Base, 8453) and enumerates the exact fields returned (number, timestamp, tx count, base fee), which separates it from transaction-level siblings like tx_activity. It does not explicitly contrast itself with any sibling, but the resource is unambiguous.

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

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

No statement of when to reach for this versus erc20_balance, tx_activity, or receipt_verify. 'For any block' only restates the input flexibility rather than giving selection guidance or exclusions such as 'use tx_activity for per-transaction data'.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful context beyond that: the comparators are assumptions rather than measurements of any bank/provider, and no protocol fee is deducted on this rail — important for interpreting the output.

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, purpose front-loaded, with the caveat about assumptions following immediately. Tight overall, though the named-but-absent parameters cost some clarity.

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

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

An output schema exists so return values need not be described, and the assumption/no-protocol-fee caveat is valuable. However, with zero required parameters and no usage guidance against siblings, an agent still lacks routing information to invoke this correctly.

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

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

Schema description coverage is 100% so the baseline would be 3, but the description names bank_fee_pct and custodial_fee_pct as caller-supplied parameters while the schema contains only amount/amount_usd/amount_usdc/currency. These phantom parameters are misleading and add no reliable value over the schema.

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

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

States a specific operation (arithmetic comparison of a USDC settlement against comparator percentages) and resource (FX savings across fiat currencies), which is enough to distinguish it from siblings like fx_spot_price_oracle or check_price. Not quite a crisp 'verb+resource' formulation, but clear.

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

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

No statement of when to use this tool versus alternatives such as fx_spot_price_oracle or check_price, and no prerequisites or exclusions. The only usage-adjacent text is that the comparators are supplied by the caller.

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 openWorldHint=true. The description adds genuinely useful behavior beyond that: no financial obligation is created, the quote_id is opaque, a TTL applies, and settlement requires an EIP-3009 signed voucher. It does not state what happens when the TTL expires, which keeps it from 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?

Three tight sentences, front-loaded with what it returns, then the zero-cost guarantee, then the settlement flow. No filler and the most decision-relevant facts come first.

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

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

With an output schema present, the description is not obligated to enumerate return fields, yet it still names the key ones. Combined with the settlement flow and zero-cost caveat, an agent has enough to call it correctly; only TTL/expiry behavior is left 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?

Schema coverage is 100%, so 'tool' and 'amount' are already documented in the schema (including the example and default). The description adds no further meaning about parameter values or formats, so the baseline 3 applies.

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

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

States a specific verb and resource ('returns the live price, an opaque quote_id, TTL, and the settlement URL') and frames the tool's role as the zero-cost pricing hook preceding code402 tool calls. This clearly separates it from the sibling validation tools (iban_check, gstin_check, etc.), none of which produce quotes.

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

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

Explains the usage context well: call it first to feed pricing into a planner's context, then hit settlement_url only if acting on the quote. It gives the when and the conditional follow-up but stops short of naming an explicit alternative tool or a when-not-to-call exclusion.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and openWorldHint=true. The description adds useful behavioral context beyond those hints: it states that validation is deterministic, includes checksum validation, and has explicit scope per identifier. It does not detail rate limits or authentication needs, but the annotations reduce the burden.

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

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

The description is compact and front-loaded: it starts with the 'one call, one receipt' value proposition, lists the covered identifiers, and then states the validation behavior. There is no redundant or wasted wording.

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

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

The tool has an output schema and annotations that cover safety and idempotency, so the description does not need to explain return values or read-only behavior. It adequately conveys the combined verification purpose and validation model, though it could clarify whether any combination of the optional identifiers is acceptable and when the pack should be preferred over single-identifier checks.

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

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

Schema description coverage is 100%, so the schema already documents all three optional parameters. The description reinforces the identifiers and specifies 'settlement IBAN' for a Chinese counterparty, but it does not add format details, checksum scope, or combination rules beyond what the schema and example already provide. Baseline 3 is appropriate when the schema carries the parameter semantics.

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

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

The description clearly states that this is a combined verification pack for Chinese counterparties covering USCC, settlement IBAN, and SWIFT/BIC, with deterministic structure and checksum validation. It implies differentiation from individual identifier checks through 'one call, one receipt,' though it does not explicitly name siblings like uscc_check or iban_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 phrase 'for a Chinese counterparty' and 'one call, one receipt' implies using this tool when multiple Chinese supplier identifiers need to be checked together. However, there is no explicit guidance on when to choose this combined pack versus the individual sibling tools such as uscc_check, iban_check, or swift_bic_check.

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

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

Annotations already cover read-only, open-world and idempotent, so the bar is lower. The description still adds real behavioral context beyond them: the no-JS constraint, the fact that output includes headings, and that the result carries a signed receipt (which pairs with the receipt_verify sibling). Rate limits and failure modes are not disclosed.

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

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

Three short sentences, front-loaded with the core action, followed by the key limitation and one notable output trait. Every sentence carries information; nothing is redundant with the title.

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

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

An output schema exists, so return values need not be spelled out, and the description still flags the two most relevant payload traits (Markdown + headings, signed receipt). The only gap is that it does not say what happens when both url and html are omitted, given that neither is required.

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

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

Schema coverage is 100% and both parameter descriptions already state the 'provide exactly one of url or html' rule plus the 1 MiB / port constraints. The description only restates the url-or-html duality, adding no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

Specific verb and resource ('Fetch a public web page by URL ... return Markdown plus headings'), with the alternate input mode named explicitly. No sibling tool in the list overlaps with web-to-Markdown conversion, so no differentiation is needed and none is missing.

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

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

'No JavaScript rendering' is an effective negative guideline: an agent can immediately tell this tool is unsuitable for JS-rendered pages. It also names the two input modes, but stops short of naming an alternative for the JS case or stating exclusions like auth-required pages.

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

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

Annotations already cover read-only, open-world, and idempotent behavior, so the description needn't repeat those. It adds meaningful context by specifying the validation method and that it returns a 'signed XDR-1 receipt,' which is useful behavioral information beyond the annotations. It stops short of describing receipt contents or any rate limits, but that's acceptable given the output schema.

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

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

Three sentences: first defines the tool, second gives use cases, third states the return. It is front-loaded with the core function and contains no redundant information. Every sentence contributes value.

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 validation tool with annotations covering safety and an output schema defining the return, the description provides everything needed: what it does, why it matters, and what it returns. No critical gaps.

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

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

The input schema fully documents the single 'cnpj' parameter, including format and punctuation allowance (100% coverage). The description adds no further semantics about the parameter, 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 states a specific verb ('Validate') and resource ('Brazilian corporate tax ID (CNPJ)'), and even specifies the algorithm ('official dual mod-11 check digits'). This clearly distinguishes it from sibling validators for other countries or formats.

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 lists concrete use cases ('Brazilian B2B payments, PIX verification, and vendor due diligence') that tell when to use the tool. However, it does not explicitly contrast with alternatives (e.g., 'use this for Brazil, not for other country IDs') or mention when not to use it, leaving a small gap in 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?

The annotations declare openWorldHint=true, but the description explicitly says there is no Companies House lookup, entity-existence check, or active-registration verification. For a pure syntax checker, the open-world annotation conflicts with the stated no-lookup behavior, so the description contradicts the annotation despite readOnlyHint and idempotentHint being consistent.

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

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

The description is two short sentences and is front-loaded with the core behavior. The exclusion sentence earns its place by preventing the agent from assuming lookup or existence verification.

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

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

Given the simple one-parameter input, full schema coverage, and the presence of an output schema, the description provides enough context for correct invocation. Its main remaining issue is the annotation mismatch rather than missing description content.

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 single company_number parameter is already documented as '8 digits, or 2 letters + 6 digits.' The description adds no additional parameter-level format detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Check supported UK company-number syntax.' It also immediately distinguishes this from Companies House lookup, entity-existence checks, and active-registration verification, so an agent can tell what class of validation this is.

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 usage boundaries by saying it is syntax-only and does not perform lookup or existence/registration checks. It does not name an alternative sibling tool for those excluded needs, but the when-not guidance is explicit.

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

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

Annotations already cover read-only and idempotency, but the description adds genuinely useful traits: deterministic output, pure function with no external calls or ML, and hashing over the exact input bytes. The only tension is openWorldHint=true versus "no external calls," though this reads as a permissive default rather than a real conflict.

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 with no filler, front-loaded with the digest components and closing with the determinism guarantee. Every clause carries information.

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

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

The tool is simple, the single parameter is fully documented, and an output schema exists, so return detail is a bonus rather than a requirement. The one gap is the absence of any indication of when an agent should reach for this tool, which for a one-param utility is the only missing piece.

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

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

Schema description coverage is 100% and the single parameter's description already states the text is arbitrary and hashed exactly as given, so the schema does the heavy lifting. The description clarifies the digest's components but adds nothing new about the parameter itself, matching the baseline 3 for fully covered schemas.

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

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

States a concrete verb+resource ("text digest") and enumerates the exact outputs: word count, top-5 frequent words with stop words excluded, first sentence, keccak-256 hash. No sibling tool performs text analysis, so the purpose is unambiguous without opening the schema.

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

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

No when-to-use or when-not-to-use guidance is given; nothing routes the agent among the finance/validation siblings or explains the intended scenario (e.g. deduping scraped text before downstream processing). "Pure function — no external calls" is a property, not usage guidance.

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

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

Annotations declare readOnlyHint=true while the description's core verb is "Create" and references "automated payments" — a direct write-vs-read contradiction. The trailing negations ("no generic bank-wire authority, independent delivery or contract-wallet guarantee") add confusion rather than disclosing what actually happens on invocation.

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 lead sentence is well front-loaded, but the two following sentences are dense, unparsable negations that consume space without conveying actionable information. Roughly half the text is noise.

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 creation/mutation tool the description never explains what is produced (even though an output schema exists, the effect of creating the invoice is unclear) or what "authorization journal" and "configured provider" mean operationally. Combined with the read/write contradiction, an agent cannot confidently invoke it.

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

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

Schema description coverage is 100%, so merchant, amount_usdc, memo, referrer and client_name are already fully documented in the schema. The description adds no field-level meaning beyond that, so baseline 3 applies.

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

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

First sentence gives a specific verb+resource: "Create a merchant-direct Base token invoice," which distinguishes it from the sibling get_b2b_invoice. The remaining sentences drift into opaque protocol jargon rather than reinforcing the 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?

No explicit when-to-use, when-not-to-use, or named alternatives. The phrase "require a durable EOA authorization journal and a configured provider" hints at prerequisites but is too cryptic for an agent to act on or to know how to satisfy them.

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, and idempotent, so the safety profile is covered. The description adds genuinely useful behavioral context beyond them: the source is public price feeds, results are cached for 60 s (implying staleness), and the result carries a signed receipt (verifiability). It stops short of stating rate limits or error behavior for unknown symbols.

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

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

Two short sentences, front-loaded with what is priced and from where, then the cache and receipt facts. No filler and nothing repeated.

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

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

An output schema exists, so return-value explanation is not required, and the signed-receipt mention is a helpful pointer. Caching and source are disclosed, but error handling for unrecognized symbols and any rate limiting are absent.

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

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

Schema description coverage is 100% and there is only one parameter, so the schema already documents the ticker-vs-CoinGecko-id duality fully. The description restates the same accepted forms without adding format or validation detail, matching the baseline 3 for a schema-complete tool.

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

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

States a specific verb+resource: spot USD price for a crypto ticker or CoinGecko id. The 'USD' and 'crypto ticker' qualifiers implicitly separate it from fiat siblings like fx_spot_price_oracle, but it never names or explicitly contrasts any sibling, so disambiguation is left to inference.

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

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

No when-to-use guidance, no when-not-to-use, and no mention of alternatives such as check_price or fx_spot_price_oracle. The only contextual detail is the data source and cache TTL, which is not 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 declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety and determinism profile is covered. The description does not clarify the one thing an agent would most worry about given the 'on Base L2' phrasing — that no announcement is actually broadcast and nothing is written on-chain, only formatted. That clarification would have added real value 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?

A single front-loaded sentence with no filler, and the key nouns (commitment, ERC-5564, stealth announcement, Base L2) appear early. It is dense with protocol jargon but every clause carries information.

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

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

An output schema exists and annotations cover safety and idempotency, so the description does not need to explain return values. What is missing is workflow context: when in the invoice lifecycle to invoke it and whether the announcement is merely serialized or transmitted, which matters for a tool that touches a public chain's namespace.

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 all five parameters individually documented including optionality and the fallback behavior for salt_hex. The description adds no parameter-level meaning beyond what the schema already states, so the baseline 3 applies.

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

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

The description names specific verbs and resources ('generates cryptographic commitments', 'formats ERC-5564 dual-key stealth address announcements') and pins the domain to invoice-scale B2B payments on Base L2, which an agent can match against sibling tools like create_b2b_invoice or receipt_verify. It is clear what the tool produces, though it bundles two outputs (commitment + announcement) without saying whether they are returned together or are independent.

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

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

There is no guidance on when to call this versus create_b2b_invoice, receipt_verify, or iso20022_to_x402_intent, all of which sit in the same payment-workflow cluster. Nothing states prerequisites, whether the invoice must be finalized first, or what the caller does with the resulting commitment.

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 openWorldHint=true, so the safety profile is covered without prose. The description adds one genuinely new behavioral fact — a signed XDR-1 receipt is returned — but says nothing about what happens when validation fails (error vs. result field) or any rate limits.

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

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

Two sentences, zero filler, and the core definition is front-loaded before the situational rationale. Nothing would be lost by keeping it exactly as is.

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 one required parameter, full schema coverage and an output schema present, the description needn't explain return shape, and it correctly frames the check as structural rather than deliverability. The one gap is failure behavior — whether an invalid number raises an error or returns a negative verdict.

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 single parameter is documented with an example, so the baseline is 3. The description goes beyond the schema by defining validity precisely (+CC prefix, 8-15 digits, no leading zero), which is real meaning the schema does not contain.

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 (Validate) and resource (E.164 phone number) and even spells out the structural rule set (+CC, 8-15 digits, no leading zero), so the agent knows precisely what operation is performed. It does not, however, distinguish itself from potential overlap with siblings such as batch_validate, which likely performs the same check in bulk.

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

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

The phrase 'before dispatching SMS alerts or OTPs' gives a concrete triggering context, which is stronger than implied usage. It stops short of explicit exclusions or naming alternatives (e.g., batch_validate for multiple numbers, or a deliverability lookup for reachability).

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description earns credit for disclosing the method (mod-10 with odd x1 / even x3 weighting), which tells the agent the tool verifies structural validity only and will not confirm the barcode is registered or in use.

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

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

One sentence, front-loaded with the verb and resource, with the checksum rule appended as the operative caveat. Nothing is wasted and nothing important is deferred.

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 fully documented parameter, full annotation coverage and an output schema handling return values, the description supplies nearly everything needed. Only the failure behavior on malformed or non-digit input is left 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?

Schema description coverage is 100% and the schema itself documents the single 'code' parameter, including that spaces and dashes are tolerated. The description adds no parameter-level detail beyond the algorithm, so it does not go past the baseline for a fully documented schema.

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

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

States a specific verb and resource ('Validate an EAN-13 barcode') and pins down exactly which check is performed (mod-10 checksum). It clearly separates itself from the many other format validators in the sibling list by naming the identifier standard, though it never explicitly contrasts itself with a sibling.

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

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

There is no statement of when to reach for this versus alternatives, and no prerequisite or exclusion guidance. The only hint about applicability is buried in the algorithm parenthetical, which an agent must infer means 'checksum only, not registry lookup'.

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

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

Annotations already cover read-only and idempotency, so the lower bar applies, yet the description still adds meaningful behavior: the check is format-only and it returns a signed XDR-1 receipt, which tells the agent a verifiable artifact comes back. It stops short of describing failure behavior (error vs. invalid-result) and does not address why openWorldHint=true for what reads as an offline syntax check.

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

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

Three short sentences that front-load the primary action and scope before usage context and return payload. No filler or restated title language beyond what is needed.

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

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

With an output schema present, the description needn't explain return fields, and it correctly spends its words on scope, usage context, and the receipt artifact. The remaining gap is what an invalid EIN produces and whether the receipt is returned on failure — the one thing an agent still has to guess.

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?

Single parameter with 100% schema description coverage ('US EIN, 9 digits; dashes/spaces allowed'), so the schema does the heavy lifting and the baseline is 3. The description's 'NN-NNNNNNN' pattern adds a concrete shape, though it slightly undersells the dashes/spaces tolerance stated in the schema.

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

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

States a specific verb and resource ('Validate US Employer Identification Number FORMAT') and pins the exact pattern (NN-NNNNNNN), with the capitalized 'FORMAT' making the syntax-only scope explicit. It is distinguishable from heavier counterparty checks, but it never names or contrasts with the many other format validators in the sibling set (pan_format_check, abn_check, e164_check, uscc_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?

'Use during US business counterparty KYB verification' gives a usage context, which is more than implied. However, there is no when-not guidance (e.g., that this does not confirm the EIN is assigned or active) and no routing to alternatives such as uscc_check or vendor_onboarding_pack for the broader onboarding flow.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds real behavioral context beyond that: decimals are read on-chain from the token, and the result carries a signed receipt — a non-obvious output trait.

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 tight sentence that front-loads the operation, the resource, and the chain, then appends the receipt trait. No filler or redundancy.

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

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

An output schema exists, so return values need no elaboration, and annotations cover safety and idempotency. Chain scoping and the signed-receipt output are disclosed; minor gaps remain around failure behavior for invalid or non-contract token addresses.

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

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

Schema coverage is 100%, so all three parameters are already documented, making 3 the baseline. The description adds marginal value by explaining that decimals are read from the token, which contextualizes the optional decimals override, but gives no syntax or format detail beyond the schema.

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

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

States a specific verb and resource (balanceOf for an ERC-20 token), pins the chain to Base, and clarifies that both raw and formatted values are returned. It does not explicitly differentiate itself from the sibling balance_check, so it falls just short of a 5.

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

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

The Base/ERC-20 scoping implies when the tool applies, but there is no explicit when-to-use, when-not, or named alternative (e.g., balance_check for native/other-chain balances). Usage must be inferred from the scope statement.

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

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

Annotations already cover read-only/idempotent/open-world safety, and the description adds genuinely non-structured context: the rate comes from a static table (staleness implication), the result includes the inverse, and it carries a signed receipt. It does not explain what the receipt is for or how it should be verified, leaving one behavioral gap.

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

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

Two sentences, zero filler, and the most decision-relevant fact (static, not live) is front-loaded before the return-shape 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 two-parameter read tool with a full output schema and safety annotations, the description covers what it does, how it differs from live feeds, and what it returns. The only omission is the meaning/use of the 'signed receipt' (e.g. whether receipt_verify should be used), which leaves a minor loose end.

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 params (base, quote) documented and exemplified, so the schema already carries the parameter meaning. The description only implies base/quote via 'fiat and stablecoin conversion rate' and adds no syntax or constraint detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource ('reference fiat and stablecoin conversion rate') and distinguishes itself from live-quote siblings (check_price, crypto_ticker) by explicitly saying 'from a static table, not a live feed'. It does not name a sibling directly, but the static-vs-live framing is enough for an agent to route correctly.

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 'static table, not a live feed' clause functions as an explicit when-to-use/when-not discriminator against the live-price siblings, which is real routing guidance. It stops short of naming alternatives or stating prerequisites (e.g. supported symbol set, staleness expectations), so it isn't 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?

Annotations already declare readOnly, idempotent, and openWorld, so the safety profile is covered. The description then adds real access-control context the annotations lack: results are limited to public records, private data requires a fresh read-only signature from the original payer, and URLs or payment vouchers are not credentials. That is meaningful added behavioral disclosure.

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

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

Two sentences, no filler, and the access restriction is front-loaded after the core capability. The phrase 'held-operation next action' is dense internal jargon that costs the reader a moment, keeping it from a 5.

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

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

An output schema exists and annotations cover the safety profile, so the description only needs to add access semantics — which it does. The one gap is that 'held-operation next action' is never unpacked, leaving the agent unsure what the second half of the return payload represents.

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 invoice_id already carries a format example (inv_a1b2c3d4e5f6), so the schema does the heavy lifting. The description adds nothing about the identifier's origin or format, making the baseline 3 appropriate for a single fully-documented parameter.

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

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

States a specific verb and resource: 'Read public recorded invoice status and held-operation next action.' The word 'public' scopes it against private records, and the read/write contrast with the sibling create_b2b_invoice is implicit. It does not name the sibling explicitly, so it stops short of a 5.

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

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

The description supplies a when-not condition — private records and credentials need a separate signature, and URLs/vouchers carry no read authority — which is genuine routing information. However, it frames this purely as an authorization rule rather than telling the agent when to call this tool versus create_b2b_invoice or receipt_verify, so usage remains implied.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds useful behavioral context by specifying the validation method: structural layout plus a mod-36 cross-sum checksum, which clarifies what 'validate' means here.

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 that is front-loaded with the purpose and is free of filler. Every clause adds information needed to understand what the tool does.

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

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

For a one-parameter validator with rich annotations and an output schema, the description is sufficiently complete. It covers purpose and validation logic, and the output schema handles return-value details, so no critical information is missing.

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

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

Schema coverage is 100%, so the single gstin parameter is already documented. The description adds value beyond the schema by breaking down the GSTIN structure (state code, PAN, entity code, 'Z') and noting the checksum, giving the agent a clear mental model of the input.

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 ('Validate') and resource ('Indian GSTIN'), and immediately names the exact format it checks (2-digit state code + PAN + entity code + 'Z') and the checksum algorithm. This distinguishes it from sibling validators like iban_check or swift_bic_check by the precise identifier type.

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

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

The description offers no when-to-use guidance, no prerequisites, and no explicit alternatives. It does not tell the agent to choose this over batch_validate for single checks or over india_supplier_check for broader supplier validation.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so safety and repeatability are covered. The description adds that validation is "deterministic structure validation" and that results come back as a "receipt," but it never says what happens on malformed input, or how an all-optional empty call behaves. The deterministic-structure claim sits slightly awkwardly against openWorldHint=true without clarifying whether any external lookup occurs.

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

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

Two short sentences, with the composite scope front-loaded ahead of the validation claim. Little waste, though "scope stated per identifier" is vague filler that does not earn 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?

An output schema exists, so return values needn't be explained, and all three optional parameters are fully documented. What is missing is the meaning of "verification" here — checksum/check-digit validation versus registry lookup — and behavior when no identifiers are supplied, which is a real gap given required=[].

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

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

Schema coverage is 100% — each of trn, iban and swift has a description plus a worked example, so the schema carries the parameter burden. The description contributes only the informal labels (UAE TRN, settlement IBAN, SWIFT/BIC) and adds no format or validation-rule detail beyond what the schema already states.

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?

"One call, one receipt: UAE TRN + settlement IBAN + SWIFT/BIC" states a concrete composite resource and makes clear this bundles three identifier checks rather than one. That distinguishes it in substance from uae_trn_check, iban_check and swift_bic_check, though those siblings are never named and the closing phrase "scope stated per identifier" is opaque.

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?

"Gulf trade corridors" implies a supplier-onboarding context, but there is no explicit when-to-use statement and no routing versus the three single-identifier sibling tools that do the same work individually. An agent must infer that this is the bundled alternative, and nothing says when a single check is preferable.

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

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

Annotations already cover safety (readOnlyHint, idempotentHint, openWorldHint), so the bar is lower. The description adds real value beyond them by explicitly bounding what the result does NOT prove — account ownership, beneficiary identity, fraud absence — which is critical for an agent deciding how much to trust a positive result.

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

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

Two sentences, zero waste, with the positive capability front-loaded and the limitation following. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained here. Combined with the scope disclaimer and a single fully documented parameter, the definition is essentially complete for a stateless validator; only explicit sibling routing 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?

Only one parameter and schema description coverage is 100% ('IBAN to validate; spaces allowed.'), so the schema fully documents the input. The description adds no syntax, formatting, or length details beyond the schema, making the baseline 3 correct.

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

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

States a specific verb and resource ('Validate IBAN structure and MOD-97 checksum'), which immediately distinguishes it from siblings like swift_bic_check, gstin_check, and vat_mod97_check. The scope is narrow and unambiguous.

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

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

Usage is implied by the purpose — call it when you need IBAN format/checksum validation — but there is no explicit when-to-use guidance or routing against siblings such as vat_mod97_check or batch_validate. The second sentence is a scope disclaimer, not invocation guidance, so this is minimum viable rather than strong.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds real value beyond that by clarifying what the check deliberately does NOT do (no registry lookup, no account verification), which prevents the agent from over-trusting the result.

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

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

Two tight sentences, front-loaded with what it does and then the scope boundary. Every clause earns its place with no filler.

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

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

An output schema exists, so return values need not be explained, and annotations carry the safety profile. For a single-parameter format validator the description supplies exactly the missing context: the scope boundary and validation rule.

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 'ifsc' parameter, so the schema already documents it; baseline is 3. The description adds a small amount of semantic detail by noting the fifth-character-zero rule, which is param-relevant, but it does not describe accepted value shapes beyond what the schema provides.

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

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

States a specific verb (Check) and resource (the 11-character Indian IFSC format), and immediately bounds the scope by naming the detail it validates (the fifth-character zero). The negative clause 'No bank-branch registry lookup or account verification' clearly separates it from richer verification tools in the sibling set.

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 explicit when-not guidance ('No bank-branch registry lookup or account verification'), telling the agent this is pure syntactic validation rather than a lookup. It does not name a specific sibling alternative, so it falls short of a full 5, but the exclusions are unambiguous.

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

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

Annotations already cover read-only and idempotency, so the bar is lower; the description adds genuine value by disclosing that these are four deterministic structural checks rather than registry-backed verifications, and that output comes as a single receipt. Mild tension with openWorldHint=true, since pure structural/checksum validation ordinarily needs no external system, but this is inferential rather than a direct 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?

Three short sentences, zero filler, and the payload ('One call, one receipt: GSTIN + PAN + UPI VPA + IFSC') is front-loaded before the supporting scope and audience notes.

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

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

With an output schema present, return values need no explanation, and annotations carry the safety profile, so the description is close to sufficient. The one gap is that it never says how to use it with partial input (all parameters are optional, and it is unclear whether one identifier alone yields a useful 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 description coverage is 100%, so each of the four identifier parameters is already documented with format hints (character lengths, optionality). The description confirms the four checks map to those identifiers but adds no format, syntax, or partial-input semantics beyond the schema, so the baseline of 3 applies.

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

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

The description names the exact resources checked (GSTIN, PAN, UPI VPA, IFSC) and frames the tool as a bundled verification call for an Indian counterparty, which implicitly separates it from the single-identifier siblings like gstin_check and ifsc_check. The verb is somewhat implicit ('checks') but the scope is unambiguous.

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

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

It states a clear usage context: cross-border procurement where the buyer is an agent that cannot open an INR account, which explains why this consolidated pack exists. It does not, however, state when to prefer it over sibling packs (batch_validate, vendor_onboarding_pack) or any 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 readOnlyHint, idempotentHint, and openWorldHint, so safety and determinism are covered structurally. The description adds almost nothing beyond that: "Preflighted for agent tool call pipelines" is a positioning claim, not behavioral detail, and it says nothing about failure behavior, error granularity, or whether validation stops at first error.

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

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

Two short sentences with the core action front-loaded. The second sentence is vaguer marketing-flavored padding, but the total length is minimal and nothing is 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?

An output schema exists, so return values need not be explained, and both required parameters are fully described in the schema with an example. What remains missing is usage routing against the similar batch_validate sibling, which a definition this simple could reasonably have included.

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

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

Schema description coverage is 100% and both parameters are documented with clear descriptions plus a worked example, so the schema carries the burden. The description adds no syntax, format, or dialect guidance (e.g., which JSON Schema draft) beyond restating that data is checked against 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+resource: "Validate JSON data payloads against schema definitions." That is unambiguous and an agent can immediately tell what it does. It does not differentiate from the sibling batch_validate, which appears to be the closest alternative, so it falls short of a 5.

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

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

"Preflighted for agent tool call pipelines" gestures at a usage context but never states when to call this versus batch_validate or why a pipeline should preflight with it. There are no exclusions and no named alternative, so the guidance is essentially absent beyond a slogan.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description usefully adds the validation algorithm (structure plus Luhn mod-10 over A=10…Z=35), which tells the agent that a plausible-looking ISIN with a bad check digit will fail, but it says nothing about failure semantics (error vs. negative result) or output shape.

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

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

A single front-loaded sentence with no filler; the scope, standard, and algorithm come first and nothing is wasted.

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

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

With an output schema, full annotation coverage, and a fully documented single parameter, the description carries only the burden of stating the validation rule, which it does. The one remaining gap is not indicating how a failed check is surfaced, but the output schema likely covers that.

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

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

Only one parameter and schema description coverage is 100%, with the schema already spelling out the 12-character layout and the spaces-allowed rule. The description adds no parameter detail beyond the A=10…Z=35 conversion, so baseline 3 applies.

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

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

States a specific verb ('Validate') and resource ('an ISIN (ISO 6166)'), plus the exact method used, which cleanly separates it from siblings like sedol_check, lei_check, and ean13_check. An agent can identify the tool's function without opening the schema.

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

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

The description says what is checked but never when to reach for this tool versus alternatives such as batch_validate (bulk validation) or the other identifier checks. No exclusions, prerequisites, or routing guidance are given.

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

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

Annotations already establish read-only, idempotent, and open-world behavior. The description adds meaningful context beyond them, especially 'zero custody, no fiat leg' and deterministic template generation, though it does not discuss auth, rate limits, or error 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?

The definition is a single dense sentence that front-loads the core transformation and settlement context with no filler. Every phrase, including custody and fiat caveats, contributes useful 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 full output schema, complete parameter descriptions, nested input objects, and annotations covering safety/idempotency, the description provides sufficient context to select and call the tool correctly. Return-value details are appropriately left to the output schema.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including chain_id default and fallback recipient. The description adds accepted ISO 20022 message types but does not explain parameter roles or interactions 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 names a specific verb and resource: translating validated ISO 20022 pain.001/pacs.008 instructions into EIP-712 payment-intent templates for x402 settlement. It clearly distinguishes this mapping step from validation by specifying the input is already validated.

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 for when to use it: after ISO 20022 validation, when producing x402 Base L2 USDC settlement intents. It does not explicitly name alternatives or exclusions, so it falls short of a full when/when-not routing statement.

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

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

Annotations already declare readOnly, idempotent, and openWorld, so safety is covered; the description goes further by naming concrete mechanics: XML DOCTYPE security guards (XXE/entity hardening), BigInt CtrlSum decimal summation, and ISO 13616/9362/17442 checksum enforcement. That tells the agent the validator is strict and deterministic, though it doesn't state the failure mode (e.g., whether it throws or returns a structured error list).

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

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

One front-loaded sentence that leads with the core capability before the parenthetical spec lists. Dense but zero filler; the packed parentheticals (message types, then three standards) cost some readability but each item carries information an agent can act on.

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 4 documented params, full schema coverage, and an output schema, the description only needs to frame scope and strictness - which it does by naming supported message types and the security/checksum regime. The remaining gap is operational: no statement about what a failed validation returns or how message type is inferred when namespace is omitted.

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%, covering raw_payload, format, namespace, and transactions, so the schema already carries parameter meaning. The description adds only indirect hints - that both XML and JSON are accepted and that namespace-scoped message types exist - without clarifying when to supply 'transactions' versus 'raw_payload' or how the namespace value interacts with auto-detection.

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 ('deterministic validation') and resource ('institutional ISO 20022 XML/JSON payment messages'), and enumerates the exact message types covered (pain.001, pacs.008, camt.053). This clearly separates it from adjacent siblings like iban_check, swift_bic_check, or iso20022_to_x402_intent, which do single-field or conversion work rather than full-message validation.

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

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

Usage is implied by the scope statement - you call it on an ISO 20022 payment message to validate it - but there is no explicit when/when-not guidance. It never says to prefer iban_check or swift_bic_check for standalone field lookups, nor what to do with non-ISO 20022 payloads, leaving the agent to infer boundaries from the message-type list.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds real value beyond that by disclosing the lookup output set, including the non-obvious onchain Base L2 settlement mapping (USDC/EURC), which an agent could not predict from annotations alone. It does not say what happens for an unrecognized code, keeping it below a 5.

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

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

Two sentences, no filler, with the validation scope front-loaded before the return-value list. Every clause carries information.

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

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

For a single-parameter read-only lookup with an output schema, the description is sufficient; return values are additionally summarized. The only gap is error/not-found behavior for unknown codes, which would be useful in a validator.

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

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

Only one parameter, and schema_description_coverage is 100%, so the schema already documents the accepted formats with examples. The description restates the alpha/numeric duality without adding syntax or edge-case detail, so the baseline 3 applies.

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

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

The description states a specific verb (validate) and resource (ISO 4217 currency codes), covering both alpha and numeric forms, and lists the returned fields. Among the sibling check tools (iban_check, swift_bic_check, ean13_check), the currency-domain scope makes it unambiguous which one to call.

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

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

Usage is implied by 'validate ... against ISO 4217 standard', but there is no explicit guidance on when to prefer this over siblings like fx_spot_price_oracle or calculate_fx_savings, nor any statement about invalid-input behavior. An agent can infer the context but is given no routing rules.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds the validation method (Mod-9) and notes a "signed XDR-1 receipt" is returned, which is useful behavioral color, but it never says what happens on an invalid number (error vs. false result) — the key behavioral question for a validator.

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

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

Three short sentences, front-loaded with the core verb and resource. The middle sentence is mildly promotional but does convey real usage context, so nothing is wasted beyond a little framing.

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

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

With an output schema present, the description needn't explain the receipt structure, and the annotations cover safety and idempotency. The remaining gap is that it doesn't clarify granularity versus japan_supplier_check — whether this is checksum-only or registry-backed — which materially affects tool selection in this crowded sibling set.

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 a single required parameter already documented as a 13-digit number with an example. The description restates the same "13-digit" constraint and adds no syntax, normalization, or edge-case guidance (e.g. handling of hyphens or the leading check digit), so it earns the baseline, not more.

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 (validate), a precise resource (13-digit Japanese Corporate Number issued by the National Tax Agency) and even the algorithm (Mod-9 check digit), which is far more than a restatement of the name. It does not, however, distinguish itself from near-siblings like japan_supplier_check or company_number_format, leaving the agent to infer whether this is a format check, a registry lookup, or a full supplier screen.

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?

"Required for Japanese B2B SaaS and enterprise billing" implies the usage context (onboarding/billing validation) but gives no explicit when-not guidance and names no alternative. An agent facing japan_supplier_check and company_number_format gets only a hint, not a routing rule.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds the useful claims that checks are deterministic and that this is a single-call/'one receipt' operation, but 'explicit scope' is never explained and no cost, coverage limits, or failure behavior are described.

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?

It is short and front-loaded, which is good, but the opening 'One call, one receipt' is slogan rather than information, and the space saved is spent on unexplained phrases like 'explicit scope' instead of usage 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. For a two-optional-parameter read-only check, the remaining gap is mainly the missing sibling differentiation and the unexplained 'scope' claim, which are modest given the surrounding structure.

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

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

Schema description coverage is 100% and both properties are documented as optional, so the schema already carries the parameter burden. The description only repeats the input names and adds the '13-digit' format hint, which is marginal value 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?

Names the required inputs (13-digit Corporate Number and a settlement IBAN) for a Japanese counterparty, so the resource is identifiable, but the actual action is never stated – it is implied by the tool name rather than a verb like 'verifies' or 'validates'. It also fails to distinguish itself from the sibling japan_corp_check or iban_check, which appear to cover overlapping ground.

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

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

There is no statement of when to use this instead of japan_corp_check, iban_check, vendor_onboarding_pack, or the other *_supplier_check variants. A reader must infer that this is the combined Japan-specific pack, but the description never says so or gives any 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 readOnlyHint, idempotentHint and openWorldHint, so the safe-read profile is covered structurally. The description adds that a 'signed XDR-1 receipt' is produced, which is useful beyond the annotations, but it does not say how an invalid PIN is reported (error vs. boolean result) or what signing entails.

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

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

Three compact sentences with no filler, leading with the validation action and format before the business context. Slightly dense but every clause carries information.

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

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

For a one-parameter validator with an output schema, the description covers format, business purpose and return artifact. The remaining gap is failure-mode behavior, which the output schema may partially address.

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 single parameter is documented in both schema and description. The description nonetheless adds semantic detail beyond the schema's '11-character KRA PIN' by decomposing the structure into A/P prefix, 9 digits and checksum character.

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

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

States a specific verb and resource ('Validate Kenyan Revenue Authority Tax PIN structure') and spells out the exact format (A/P + 9 digits + checksum). This clearly separates it from sibling format validators like ein_format_check or company_number_format.

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 names the triggering contexts: 'Required for M-Pesa B2B disbursement and Kenyan remote agency invoicing.' That is real when-to-use guidance, though it gives no when-not conditions or pointers to alternatives such as batch_validate for bulk PIN checks.

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

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

Annotations already cover read-only, idempotent, open-world, so the bar is lower, and the description still adds genuinely new behavioral facts: the call is paid, results are deterministic, and you get a single combined receipt rather than three responses. It does not say what happens if only one or none of the (all-optional) parameters is supplied.

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

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

Two tight sentences with the value proposition front-loaded. 'One call, one receipt' is slightly promotional but serves to convey the bundling benefit quickly, so almost nothing is wasted.

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

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

An output schema and annotations carry most of the load, but with zero required parameters the description should clarify whether a single identifier is a valid call or whether all three must be present to justify the paid invocation. Cost magnitude and partial-input behavior are left unstated.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters and their optionality. The description restates the same three identifiers without adding format, validation, or interaction rules, so baseline 3 applies.

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

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

Names the specific resource (a bundled supplier check over CNPJ + RFC + IBAN) and the verb (verify/check in one call). It is distinguishable from single-field siblings like cnpj_check and rfc_check because it explicitly frames itself as a combined pack, but it never names those siblings directly.

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

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

'In one paid call' implies the use case is consolidating multiple single-country checks, but the description never states when to prefer this over cnpj_check + rfc_check + iban_check, nor when a sibling like vendor_onboarding_pack or africa_supplier_check is the better fit. Usage is implied rather than specified.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint. The description adds meaningful behavioral context beyond that: despite openWorldHint=true, this is a pure offline format/checksum check with no external registry call, no registration-status lookup and no identity verification — a real clarification of the tool's actual behavior.

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

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

Two sentences, zero waste, with the core action front-loaded and the scope exclusions immediately after. Nothing needs to be trimmed.

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 validator with an output schema and full annotations, the description covers what is checked and what is explicitly out of scope. Only minor gaps remain (nothing on error/return signaling), which the output schema largely absorbs.

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 single 'lei' parameter is fully documented in the schema. The description reinforces the 20-character length and MOD-97 algorithm but adds no format or normalization detail beyond that, so the baseline 3 applies.

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

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

States a precise verb+resource: validating a 20-character LEI with MOD-97 check digits. The second sentence draws explicit boundaries ('No registry lookup, active-registration check or legal-entity identity verification'), which separates it from registry/identity siblings like sanctions_address_screen or vendor_onboarding_pack.

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 negative scoping ('No registry lookup, active-registration check or legal-entity identity verification') tells the agent exactly when this tool is insufficient, which is genuine routing guidance. It stops short of naming the alternative tool for those excluded cases, so it is 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds that validation is deterministic and that the 4th character encodes entity type, which is useful behavioral context. It does not explicitly state that this checks format only and does not confirm the PAN is active or registered with CBDT, which is an important distinction an agent would need.

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

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

A single front-loaded sentence that states the resource, issuer, validation nature, and the entity-type classification. There is no filler or repetition.

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

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

An output schema exists, so return values need not be explained, and annotations cover the behavioral safety profile. The description is complete enough for an agent to call the tool correctly. The main residual gap is not clarifying that this is a pure format check rather than an existence or registration verification.

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 one parameter and 100% schema description coverage, the schema already documents the 10-character PAN string and provides an example. The description's mention of the 4th-character entity classification is relevant to interpreting the input but does not add parameter-level detail (e.g. format constraints, checksum expectations) beyond 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 names a specific verb (validation) and resource (Indian PAN issued by CBDT / Income Tax Department), and adds the 4th-character entity type classification, which distinguishes it from generic checks. It does not explicitly contrast with sibling validators (e.g. gstin_check, india_supplier_check), so it stops short of a 5.

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

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

Usage is implied by the name and description: this is a deterministic format validation of a PAN string. There is no explicit guidance on when to use it versus alternatives or when not to use it (e.g. for verifying PAN existence or linking to a supplier).

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 readOnly/idempotent hints, it discloses two things annotations cannot: the receipt-hash prerequisite and that the result is advisory — not verified identity, fraud clearance or release authorization. That is genuine expectation-setting about output trust level.

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

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

Three tight sentences with the scope, the prerequisite and the disclaimer, and the resource checked is front-loaded. No filler, though the identifier list could be compressed.

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?

Output schema and annotations are rich, and the advisory disclaimer is helpful. But the description says a receipt hash is required while the schema declares zero required parameters, leaving the agent unsure what minimum input actually produces a useful 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 description coverage is 100%, so all nine parameters are already documented; the description only restates the identifier families at a high level. It adds no format, precedence or minimum-input guidance.

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

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

States a specific verb+resource: it checks a named set of counterparty identifiers (IBAN, LEI, EU VAT, UK company number), domain-age evidence and country mismatch in a pre-payment context. That composite scope is distinguishable from single-identifier siblings like iban_check or lei_check, though no sibling is named explicitly.

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

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

'before vendor payment' plus 'Requires a preceding receipt hash' gives a clear trigger and prerequisite. It does not say when to prefer the individual validators (iban_check, lei_check, vat_mod97_check) over this composite guard, so exclusion guidance is absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds genuinely useful non-annotation context: statelessness, no quota/account, and the crucial trust caveat that a valid receipt does NOT prove funds moved or any business claim. That semantic boundary is valuable behavioral disclosure 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?

Three tight sentences: what it does, the operational guarantees, then the trust-boundary caveat. All front-loaded and every sentence earns its place.

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

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

With an output schema present, return values need no explanation. The description covers scope (any issuer), cost (free), state (stateless), and the meaning/limits of a valid result — everything an agent needs to call it correctly.

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

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

Schema description coverage is 100% and the schema itself enumerates every receipt field with an example, so the description carries no extra parameter burden. 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 and resource ('verifies a signed XDR-1 receipt from ANY x402 service') and describes the exact mechanism (recomputes canonical digest, recovers signer, compares to declared signer). This is clearly distinguishable from the sibling checking tools (iban_check, gstin_check, etc.).

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

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

Usage context is implied by 'from ANY x402 service' and 'free forever', but the description never states when to use this versus batch_validate or the other validation siblings, nor any prerequisites or exclusions. Adequate but with a clear routing gap.

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 read-only, open-world, idempotent annotations, the description adds strong behavioral context: matching is deterministic, based on end-to-end IDs and BigInt-exact amounts, facts are computed only from documents, and the tool returns a signed XDR-1 receipt. This tells the agent exactly how the tool behaves and why its verdicts can be trusted.

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 dense sentences with no wasted wording. It front-loads the core reconciliation purpose, then lists verdicts and receipt behavior, so an agent can grasp the tool's scope immediately.

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 complex reconciliation tool with four optional inputs, full schema coverage, annotations, and an output schema, the description is complete enough. It explains accepted document types, matching logic, verdict categories, and receipt generation without redundantly detailing return structure already covered by the output schema.

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

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

Schema description coverage is 100%, and each parameter already documents its role and alternatives (for example, nacha_ach instead of camt053_xml). The description adds useful matching semantics but does not provide additional parameter-level details beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific reconciliation purpose: comparing pain.001/pacs.008 instructions against camt.053 statements or NACHA ACH files. It names the exact document types, matching keys, and verdict categories, which clearly distinguishes it from sibling validation tools such as iso20022_validate.

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

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

The description implies usage by specifying the input combinations (pain.001/pacs.008 versus camt.053/NACHA), but it does not explicitly say when to choose this tool over alternatives or when not to use it. No exclusions or alternative tool names are provided.

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