Stablecoin rails, corridors and payment provider data

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

No annotations exist, so the description carries the full burden and does well: free, deterministic, no external calls, 60 calls/min per client, and an explicit negative scope ('says nothing about who controls an address'). It omits error behavior for malformed chains, which keeps it short of a 5.

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

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

Front-loaded as a question that states the core purpose immediately, then cost/scope/rate-limit details. The mid-sentence parenthetical listing outputs is 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?

With no annotations and no output schema, the description must supply everything, and it does cover inputs, per-chain behavior, outputs, cost, rate limit, and scope limits. It stops short of describing return shape or failure modes, which is the only remaining gap for a stateless check.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds real semantics beyond it: the chain parameter selects the validation regime (EIP-55 vs base58/32 bytes), and it enumerates the outputs tied to the address input (valid, checksummed form, checksum correctness, casing).

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 framing ('is this address well formed for this chain, and what is its EIP-55 checksummed form?') and names the two supported families (EVM EIP-55, Solana base58). It is trivially distinguishable from every sibling tool, none of which touch address 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?

Gives clear context (free, deterministic, no external calls) and an explicit scope boundary: 'Format only; says nothing about who controls an address.' That tells the agent when NOT to rely on it. No alternative tool is named, but no sibling overlaps functionally, so there is nothing to route against.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well. It discloses the 60 calls/min per client limit, that TARGET includes weekend closures, that IE and UK calendars list holidays only, that IE weekend substitution days are not modelled, and what each mode returns.

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

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

The description is front-loaded with the core question and then packs scope, invocation modes, calendar limitations, and rate limit into a few dense sentences. Every sentence contributes information an agent needs before calling the tool.

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

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

For a three-parameter tool with no output schema or annotations, it explains both return modes, the calendar options, and important calendar edge cases. The only notable gap is the absence of guidance on what happens if neither date nor year is supplied, or if both are supplied.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds meaningful semantics: date drives a closed true/false answer with reason, year drives a list of closures, and the calendar parameter maps to target, ie, uk-ew, uk-sco, or uk-ni. It does not explain what happens if both date and year are omitted.

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

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

The opening question states the exact decision the tool supports: whether a named payment rail is closed on a date, or which days it is closed in a year. It also names the supported calendars (TARGET, Ireland, UK variants), so an agent can immediately tell this apart from unrelated siblings such as check_regulator or stablecoin_rails.

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

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

It explicitly tells the agent how to use the two modes: provide date=YYYY-MM-DD for a true/false closure result with reason, or year=YYYY for a list of closures. It does not name a competing sibling or an explicit when-not-to-use condition, but no sibling tool overlaps this calendar-checking purpose.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that matching is exact or fuzzy, that results include match_quality and an ambiguous flag, that candidate records carry status/competent authority/source URL, that ESMA attribution and register links are returned, and it adds a 60 calls/min per-client rate limit plus the negative-result caveat.

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

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

Front-loaded as a question with the register variants in parentheses, then capabilities, then return shape, then caveat and rate limit. Dense but every sentence adds information; the parenthetical register list is the only mildly heavy element.

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

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

For a read-only lookup with no output schema, the description supplies the return shape, the ambiguity/quality semantics, the negative-result interpretation and operational limits. Nothing an agent needs to call this correctly 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 baseline is 3. The description still adds value beyond the schema by specifying the matching behaviour ('exact or fuzzy'), the either/or relationship between name and ref (LEI), and that country narrows name matches only.

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?

Opens with a specific question ('Is this firm on the ESMA MiCA register') and enumerates the exact register variants it covers (CASP, e-money token issuer, white paper, non-compliant warning list). Combined with 'look up a firm ... by name ... or LEI', an agent knows the verb, the resource and the scope 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?

States the operating context clearly ('Free', per-client rate limit) and gives an important interpretive guardrail: 'Absence from the register is not clearance.' It does not name alternatives or exclusion cases, but the listed siblings (chain, corridor, provider lookups) are in unrelated domains, so the routing risk is low.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the $0.03 cost, payment protocols (x402 on Base, MPP on Tempo), the HTTP 402 response behavior, the specific endpoint URL, and the fact that the server holds no wallet and never pays. These are exactly the operational details an agent needs before calling a paid tool.

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

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

The purpose is front-loaded, but the description is repetitive: the $0.03 price is stated twice and the payment procedure is spread across several sentences. The core information is useful, but some duplication and the rhetorical opening question reduce efficiency.

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 paid tool with no output schema, the description sufficiently explains what is returned: published corridor data with rails, speed, fee notes, citations, plus inferred on/off-ramp routes labelled as inferred. It also explains the payment prerequisite and endpoint. It does not detail pagination or full response shape, but it is complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents from, to, and country with examples. The description reinforces that from/to are currency or stablecoin values and country is the destination scope, but it does not add syntax or format details 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 clearly identifies the resource: money-movement corridors from one currency or stablecoin to another, optionally scoped by country, including published and inferred routes. It is specific enough for an agent to understand the tool, but it does not explicitly distinguish this from sibling tools such as search_providers or stablecoin_rails.

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

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

The description explains the paid invocation workflow, but it never states when to use this tool versus alternatives. Sibling tools like search_providers and stablecoin_rails could plausibly overlap, and the description provides no routing guidance between 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?

With no annotations, the description carries the burden and does so well: it discloses cost ($0.001 USDC per call), that missing facts are returned as the literal "unknown", that unknown chains/malformed input yield 404/400 and are never charged, that the server holds no wallet, and that it returns an HTTP 402 challenge rather than paying. It stops short of describing pagination or rate limits, which is minor for a single-record lookup.

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 key facts are front-loaded, but the text is bloated and self-repeating: the price is stated twice ('Paid ($0.001 USDC)' and 'Paid: $0.001 per call'), and the full payment URL plus retry instructions consume a large share of the budget for what is effectively a one-parameter lookup.

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 paid, no-annotation, no-output-schema tool this covers the essentials: what is returned, how absent data is represented, error codes and charging policy, and the full payment handshake. The main residual gap is that the field list is enumerated but not typed or exemplified.

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 `chain` parameter is fully documented with examples (base, solana, eip155:8453), so the schema already does the work. The description adds only indirect guidance, indicating that unrecognized chain values return 404 rather than erroring silently.

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 opening question and the 'Cited chain facts from a prepared dataset' clause name a specific resource and enumerate the returned fields (CAIP-2 id, gas token, finality class, explorer, x402/MPP settlement, stablecoins). That is enough to separate it from siblings like get_token or get_provider, though the differentiation is implicit rather than stated.

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

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

The description is clear on the mechanics of use (pay the 402 challenge with your own x402/MPP client, then retry the given URL) and on error behavior, but it never says when to prefer this over get_token or search_providers. Usage is implied by the resource name only.

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

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

With no annotations, the description carries the behavioural burden and does so well: it discloses the call is free, that the content is an example taken verbatim from a real record, that it is labelled as such, and that it carries a last-verified date. This is exactly the kind of provenance information an agent needs to avoid treating sample data as live. It stops short of explaining freshness guarantees or pagination.

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

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

Every sentence carries information, but the second sentence opens with a dangling "Free:" fragment that reads awkwardly, and the opening question format delays the actual resource description. It is reasonably front-loaded but not cleanly structured.

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

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

With no output schema, no annotations, and no parameters, the description must stand alone — and it describes the return payload (prices, paths, one full sample response with provenance labelling) well enough for correct invocation. Minor gaps around response freshness beyond the single verified date remain.

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

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

The tool takes zero parameters, so there is no parameter semantics to add; the baseline for a no-param tool is 4. The description correctly implies the call is parameterless by addressing it as a fixed catalogue lookup.

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

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

The description states a concrete resource — the catalogue of paid endpoints with their prices and paths — plus one full example response for GET /v1/provider. That is specific enough to distinguish it from siblings like get_provider, which returns live provider data. It is framed as a question rather than a verb+resource statement, which costs it a point.

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

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

"Use it to see the shape and depth of paid data before paying" gives a clear when-to-use trigger: previewing paid data before committing to spend. It does not explicitly name an alternative tool, so the contrast with get_provider must be inferred.

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

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

With no annotations, the description carries the full burden and does so exceptionally: it discloses the paid cost ($0.01 USDC), that the server holds no wallet and never pays, that the first response is an HTTP 402 with payment requirements, which protocols are supported (x402 on Base, MPP on Tempo), and the exact URL to retry. An agent will not be surprised by a 402 response or accidentally assume the tool performs payment.

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 payment model is stated twice ('Paid ($0.01 USDC)' up front and 'Paid: $0.01 per call (x402/MPP)' at the end), and the rhetorical opening question delays the core statement slightly. The content is dense and useful, but a sentence of duplication could be cut.

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 tool with no output schema, the description supplies everything required: what the record contains, that every fact is cited with source URL, retrieval date, quote and confidence, and the full payment handshake to expect. Nothing needed to call it correctly 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 the schema already documents it fully (100% coverage) including the example 'circle'. The description restates the single-provider scope but adds no syntax or format 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 and resource: 'Full cited record for one provider', then enumerates exactly what that record contains (rails, corridors, licences, fees, coverage, developer support). The id description ties it to search_providers, so an agent can immediately tell this is the detail-view sibling of the search tool.

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

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

The line 'Provider id from search_providers' establishes the workflow prerequisite (search first, then fetch detail) and implicitly excludes list-style use. It does not state exclusions explicitly (e.g. don't iterate this for discovery), so it falls short of a full when/when-not treatment.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses payment requirements, the 402 flow, that the server holds no wallet, dataset limitations, unknown-field behavior, and charge/no-charge conditions.

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

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

The description is front-loaded and mostly purposeful, covering payment and dataset constraints that matter for invocation. It does repeat the pricing in two places and is somewhat verbose, but the structure remains usable.

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 paid API, lack of output schema, and lack of annotations, the description provides the needed context: dataset coverage, returned fields, citation/license behavior, unknown values, error handling, and payment retry mechanics.

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 input schema already documents chain, symbol, and address. The description adds dataset scope but does not provide significant additional parameter semantics beyond the schema.

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

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

The description clearly identifies the resource and returned fields: stablecoin token facts including symbol, name, decimals, contract address, chain, and issuer. It is easy to distinguish from chain-level tools, but it does not explicitly name sibling alternatives or contrast itself with them.

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

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

Usage is implied for looking up stablecoin metadata, and the description states dataset coverage and that missing tokens return 400/404 without charge. However, it does not explicitly say when to use this versus siblings such as get_chain or stablecoin_rails.

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

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

With no annotations, the description carries the full burden and does well: it declares cost ("Free"), the rate limit ("50 calls/day per client"), and the return shape ("compact cards (no citations)"). It does not state pagination/result-count limits or that empty filters return a broad listing, so it is strong but not exhaustive for a zero-annotation tool.

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

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

Front-loaded question followed by tightly packed clauses covering scope, cost, return format, alternative tool, and rate limit in four sentences. Dense but every clause carries information; only the slight redundancy between the question and the second sentence costs a point.

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

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

For a six-parameter, fully-documented, filter-only search tool with no output schema and no annotations, the description supplies cost, rate limit, result format, and the escalation path to get_provider. What is missing is minor: no note on result count/pagination or behavior when all optional filters are 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%, so the schema already documents all six parameters with format examples. The description mostly restates those facets, adding only the mild nuance that country means on/off-ramp coverage; baseline 3 is appropriate when the schema does the heavy lifting.

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

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

Opens with a concrete question that names the resource (payment/stablecoin providers) and the exact facets searched (asset, chain, country, service/category). It also explicitly distinguishes itself from the sibling get_provider, so an agent can separate the two without opening either schema.

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

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

"use get_provider for the full cited record" names the alternative and the condition that selects it, and the leading question frames the intended query context. No explicit when-not guidance (e.g., do not use for name-only or non-provider lookups) is given, so it stops short of a 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?

With no annotations, the description carries the full burden and does so: it discloses the $0.01 cost, that the server holds no wallet and never pays, that it returns HTTP 402 payment requirements (x402 on Base, MPP on Tempo), and the exact retry URL. It also describes the returned block contents and the listed-vs-global country match semantics.

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

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

The core question and resource scope are front-loaded in the first two sentences, and the payment mechanics follow in a logical order. There is mild redundancy in stating the price twice ('Paid ($0.01 USDC)' and 'Paid: $0.01 per call'), which keeps it from being maximally tight.

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

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

No output schema exists, so the description must explain returns, and it does: assets, chains, ramp countries, fiat rails, custody model, plus the cited block per provider. The payment negotiation flow is fully spelled out; only return size/pagination behavior is left unstated.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds meaning beyond the schema by explaining that country matches distinguish explicitly listed countries from 'global' coverage claims. The other three parameters are only echoed, so it does not reach a 5.

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 opening question plus the clause 'Stablecoin rails by asset, chain, country and service' names a specific resource and the dimensions it slices on, so an agent knows exactly what it returns. It does not explicitly contrast itself with siblings like search_providers or find_corridor, keeping it below 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 described procedurally (pay with your own x402/MPP client, then retry the URL), which is genuinely useful. However, there is no guidance on when to choose this over sibling tools such as search_providers, find_corridor, or get_provider; the when-vs-alternatives dimension is left to inference.

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