SiteCheck

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

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses that Workers AI performs the split (implying non-determinism, with the explicit warning 'check the parts'), that postcodes are validated against 18 country rule sets and a mismatch is dropped and reported, that geocoding comes from OpenStreetMap Nominatim, and that pricing is $0.002 USDC per successful call via x402 with failed calls uncharged.

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

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

Purpose and output fields are front-loaded, followed by the validation caveat, the reliability warning, and pricing. Every sentence carries information, though the density (four packed clauses covering parsing, validation, geocoding, and payment) makes it slightly heavy for a single paragraph.

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 format need not be explained, and the description still covers the failure mode (postcode mismatch omitted and reported), the reliability caveat, the geocoding side effect, and the x402 payment terms. 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 description coverage is 100%, so the baseline is 3. The description largely restates the schema (geocode pulls OSM coordinates, country improves the postcode check) and adds only the incidental detail that 18 countries are covered and that the geocode source is Nominatim.

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 ('splits') and resource ('free-text postal address') and enumerates the exact output components (house number, street, unit, postcode, city, district, region, country plus a normalised one-line form). This clearly separates it from the geocode, us_geocode, and postcode siblings.

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

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

Usage is implied rather than stated: 'geocode=1 adds coordinates' lets an agent infer it can substitute for the geocode tool, and 'country ... improves the postcode check' hints at when to supply the optional field. But there is no explicit when-to-use/when-not statement or direct comparison with the geocode, postcode, or us_geocode siblings.

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

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

Annotations only cover readOnlyHint and openWorldHint, and the description adds substantial behavior beyond them: a $0.002 USDC per-call price, x402 payment rails (Base, Solana, Arc), the fact that failed calls are not charged, and the no-JavaScript execution model. Pricing and billing semantics are exactly the kind of information annotations cannot express.

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 dense but well-ordered passage: coverage first, then the execution caveat, then the price. Every clause carries information, though the parenthetical crawler list and payment-rail enumeration make it heavy for one sentence.

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 explanation; the description still tells the agent the scope (eleven crawlers, with examples), the three data sources checked, the rendering limitation, and the cost. 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?

One parameter with 100% schema description coverage ('Page address, https://…'), so the schema already carries the full parameter semantics. The description adds nothing about the url beyond confirming the page is fetched as static HTML; 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?

Names the specific resource (eleven named AI crawlers) and the exact outputs: robots.txt allow/block status, noai/noimageai meta and X-Robots-Tag opt-outs, and llms.txt existence. That is far more specific than a tautology, but it never distinguishes itself from overlapping siblings such as robots, llms_txt, meta, or headers, which an agent must disambiguate against.

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

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

Usage is only implied: the 'static HTML; no JavaScript runs' caveat tells the agent this fails on JS-rendered pages, which is useful context. However, no when-to-use, when-not-to-use, or named alternative is given, despite several close siblings (robots, llms_txt, meta, headers) that could be confused with it.

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

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

Annotations already state readOnly and openWorld, but the description adds substantial non-annotation behavior: $0.002 USDC per successful call via x402, failed calls uncharged, coverage limited to large/medium and IATA-coded airports, and explicitly no time zone. These are decision-relevant constraints beyond structured fields.

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 packed into a few front-loaded clauses: resource, lookup modes, coverage caveats, returned fields, and pricing. Every sentence carries useful information without 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?

Given an output schema, readOnly/openWorld annotations, and full schema descriptions, the description supplies the remaining decision-critical facts: source, coverage exclusions, missing time zone, and x402 pricing. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100% and documents all six parameters including code, q, lat/lon, limit, and radiusKm. The description only echoes that q is name/city words and radius is up to 300 km, both already in the schema; 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 ('Airport lookup') and resource ('OurAirports extract'), enumerates the three lookup modes, and names returned fields. The airport-specific scope naturally distinguishes it from general geocoding/places siblings.

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

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

It clearly explains the supported query modes (code, name/city words, nearest within radius) and coverage limits, but never names alternatives such as geocode, places, or flights. The agent must infer when to choose this tool over those siblings.

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

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

Annotations only cover readOnlyHint and openWorldHint, yet the description adds material operational detail: a metered price ($0.002 USDC per successful call), the x402 payment rails (Base, Solana, Arc), and the fact that failed calls are not charged. It also clarifies that ratings are the storefront's averages for the selected country, which prevents misreading 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?

Front-loaded with what the tool does, then the operational constraints and price. The enumerated return-field list is slightly redundant given an output schema exists, but it is compact and every clause carries usable 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 4-param, zero-required tool with an output schema and safety annotations, the description covers mode selection, defaults, the 50-result cap, result semantics, and the payment/auth requirement. Nothing needed to invoke 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?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: 'Country sets the storefront (default us)' and 'Ratings are the store's averages for that country' explain the semantic effect of the country parameter on returned data, which the schema text alone does not convey.

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 specific verbs and resources: 'Searches the App Store (iTunes Search API) by keyword, or looks up one app by its numeric id.' It also names the exact data returned (name, developer, bundle id, price, rating, etc.), so an agent can distinguish it from near siblings like package_search or github_search.

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

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

It clearly distinguishes the two modes (keyword search vs. single-app lookup by id) and implies the id path is the alternative to q. It does not explicitly state when NOT to use it versus other store/search tools, but the context is 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 only mark this read-only and open-world; the description goes well beyond them by disclosing sort order (newest first), the 25-result ceiling, summary truncation at 500 characters, and a cost/payment model ($0.002 USDC via x402, failed calls free). The per-call price is critical behavioral context for an agent deciding whether to invoke.

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 dense but front-loaded sentence covers scope, ordering, limits and returned fields; the attribution and pricing lines are separated and each carries actionable information. No filler, though the single sentence packs a lot of clauses.

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 need not detail return structure, yet it still names the key fields returned. For a read-only, three-parameter search tool, the only real gap is failure-mode behavior and the meaning of the limit string type.

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 q, limit and category with a default value. The description adds only a bit of meaning (one category, newest-first ordering, max 25) and does not explain the discrepancy in emphasis between 'max 25' and the schema's stated default of 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?

Opens with a specific verb-resource pair ('arXiv papers matching search terms') and scopes it (single optional category, newest first, max 25). It is clearly an arXiv search tool, though it never distinguishes itself from sibling academic search tools like pubmed or research_papers.

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 'optionally in one category' and 'max 25' imply the usage pattern, but there is no explicit statement of when to pick this over pubmed/research_papers, nor any prerequisites or 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 cover the safety profile (readOnlyHint=true, openWorldHint=true), so the bar is lower, yet the description adds genuinely new behavioral context: a $0.02 USDC cost per call, the x402 payment rails (Base, Solana, Arc), and that failed calls are not charged. It omits return format, but an output schema exists to carry that.

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 dense but front-loaded sentence: capability first, then the enumerated coverage, then pricing. Every clause earns its place with no filler, though the sentence is long enough to be slightly effortful to scan.

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

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

For a one-param tool with a rich output schema, the description covers purpose, delivered dimensions, and the notable commercial constraint. It lacks prerequisite or eligibility guidance, but return values need not be explained given 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 the single 'url' parameter is already documented in the schema ('Website URL or domain, e.g. example.com'). The description adds no syntax, format, or constraint detail 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?

States a specific verb+resource ('Website audit in one call') and enumerates the covered domains: WCAG 2.2 accessibility, SEO basics, security headers, and tech stack. This lets an agent see it bundles multiple concerns, but it never names the overlapping siblings (headers, tech, meta, pagespeed) it consolidates, so differentiation is implicit rather than explicit.

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

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

The phrase 'in one call' implies the usage context: reach for this instead of making several single-purpose calls. However, there is no explicit when-to-use/when-not guidance and no named alternatives among the many overlapping siblings, leaving the agent to infer selection.

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

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

Beyond readOnlyHint/openWorldHint, it discloses the commercial model ($0.002 USDC via x402 on Base/Solana/Arc), that failed calls are not charged, that a missing title is a 404 rather than a billable miss, the 20-result cap, and the CC0 Open Library provenance. These are concrete operational traits an agent cannot get from annotations.

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

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

Purpose and lookup modes are front-loaded, and the closing sentences carry pricing and error semantics efficiently. The long enumeration of returned fields is somewhat redundant given an output schema exists, which costs a little economy.

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 annotations covering safety, an output schema covering return shape, and a fully described schema, the description still supplies the missing pieces: payment mechanism, billing on failure, 404 semantics, and result caps. Nothing an agent needs before calling is absent.

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

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

Schema coverage is 100%, so the schema already documents isbn, limit, title and author. The description adds only that ISBN is validated before the call and that results cap at 20, which maps to the limit parameter but adds no new format or interaction rules.

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 ('Book lookup by ISBN ... or by title and/or author') and names the exact retrieval modes. It is clearly distinguishable from sibling bibliographic tools such as doi, arxiv, wiki, and wikidata.

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 selection context: use ISBN when already known, otherwise title and/or author, and warns that a non-matching title returns 404. It does not name an alternative sibling for cases where a different lookup source is better, so it stops short of full when/when-not routing.

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

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

Annotations only cover readOnly/openWorld, but the description adds substantial behavioral context: the data source (mempool.space), the fact that unconfirmed balance is included, and a precise pricing model ($0.002 USDC per successful call via x402; failed calls are free). The cost and charging semantics are exactly the kind of non-obvious behavior an agent needs before invoking.

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 content is densely front-loaded in one sentence that leads with what the tool returns. The trailing 'Information only, not financial advice' is mild boilerplate, and the return-field list overlaps with the output schema, but overall it is efficient and well-ordered.

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 lookup with an existing output schema and rich annotations, the description leaves nothing essential out: source, scope, return contents, and payment terms are all covered. An agent has everything needed to decide to call it and to predict the outcome.

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 a single required parameter and 100% schema description coverage, the schema already documents the address field. The description's 'bech32 and legacy only' note slightly reinforces the accepted formats but adds no new syntax, validation, or format detail 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 resource (a Bitcoin mainnet address) and enumerates exactly what is returned: confirmed/unconfirmed balance in BTC and USD, transaction count, funded/spent totals, and last 10 transactions. It is clearly distinguishable from siblings like evm_address, solana_account, btc_tx, or address_parse, since it pins the chain and the entity.

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 scope constraint — 'Mainnet bech32 and legacy addresses only' — which effectively tells the agent when this tool will and will not work, and the address format hint narrows selection further. It stops short of naming alternative siblings (e.g., btc_tx for raw transactions), so it's strong context without explicit routing.

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

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

Goes well beyond the readOnlyHint/openWorldHint annotations: names upstream data sources (mempool.space, Coinbase spot for USD), discloses a 30-second cache TTL that bounds data freshness, and states the exact paid-call model ($0.002 USDC via x402, failed calls not charged). These are precisely the operational facts an agent needs before invoking.

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

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

Front-loaded with the returned data and organized logically (outputs, then sources, then caching, then pricing). The payment/legal sentence is long and slightly boilerplate-heavy, but each clause still carries distinct 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 parameters and an output schema already available, the description fills exactly the remaining gaps: data provenance, freshness guarantee, and cost per call. Nothing an agent needs in order to decide to call it and interpret the result is missing.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to clarify. The description correctly documents none are required and instead spends space on the shape of the response.

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

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

States a specific resource (Bitcoin fees in sat/vB) and enumerates exactly what comes back: fee tiers (fastest/30m/1h/economy/minimum), mempool size and count, and a 140 vB transaction cost in BTC and USD. This is clearly distinguishable from EVM-oriented siblings like gas or defi_fees without opening any 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 enumerated outputs imply when the tool is relevant (fee estimation, mempool congestion checks), but there is no explicit when-to-use or when-not-use statement, and no named alternative among the many crypto siblings. The 'Information only, not financial advice' line is a disclaimer, 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 and openWorldHint, and the description goes further by disclosing the upstream source (mempool.space), a per-successful-call price with the x402 payment rails, and the fact that failed calls are not charged. It also notes unconfirmed-transaction and replace-by-fee handling. Only rate limits or error semantics are absent.

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

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

Front-loads the resource and lookup key, then packs return fields, source, disclaimer and pricing into a compact block with no filler sentences. Every clause carries either selection signal or behavioral 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 the return-field enumeration is not strictly required, but combined with the disclosed source, cost model and payment failure policy the description gives an agent nearly everything needed to call it. Only guidance on failure/retry behavior 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?

There is a single parameter with 100% schema description coverage ('Transaction id, 64 hex characters'), which sets the baseline at 3. The description restates the lookup key as 'txid' but adds no format, normalization, or edge-case guidance 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 ('A Bitcoin transaction by txid') and then enumerates the exact returned fields, so an agent can distinguish it from btc_address, btc_fees, evm_tx and solana_tx without opening any schema. The chain and lookup key are both 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?

Usage is implied by the txid lookup and the mempool.space source, but there is no explicit when-to-use statement and no mention of alternatives (e.g. evm_tx for EVM chains or btc_address for address-level data). The agent must infer routing from the name alone.

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

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

Annotations only cover read-only/open-world safety, yet the description adds substantial uncaptured behavior: the x402 pricing model ($0.002 USDC, Base/Solana/Arc), the rule that failed calls are not charged, the 404-not-charged behavior for countries with no holiday data, and per-country weekend variations. These are exactly the operational facts an agent needs before invoking a paid endpoint.

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

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

Front-loads the purpose, then mode semantics, then edge rules, then cost — a sensible order. The pricing sentence is long but every clause (asset, chains, failure policy) carries decision-relevant information, so little 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 present, return values need no explanation; the description instead covers the things the schema cannot: weekend rules per country, holiday data source, error semantics, caps, and payment terms. 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 earns an extra point by clarifying the counting semantics ('after `from` up to and including `to`') and the caps (5-year span, 3,650 days), which the schema does not fully articulate. It also disambiguates that `days` may be negative for subtraction.

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

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

States a specific resource ('working days for a country') and then precisely defines the two operations it performs (counting between dates, adding N days). It implicitly separates itself from the sibling `holidays` tool by noting holidays are what gets *skipped*, but it never names an alternative, so sibling differentiation is only partial.

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

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

Gives clear in-tool routing: mode=between vs mode=add, each with its required inputs and caps. It does not address when to prefer this over `date_calc` or `holidays`, which is the main remaining gap for an agent choosing among siblings.

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

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

Annotations already cover readOnly and openWorld safety. The description adds genuinely useful non-schema behavior: answers cached for an hour, one request per call, a per-success price of $0.002 USDC via x402 with named payment chains, and that failed calls are not charged. Only the return-shape detail overlaps what the output schema likely carries.

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

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

Front-loaded with the returned fields, then operational and pricing details in a compact flow. Slightly dense but every clause (caching, 100-DNS-name cap, billing) carries information; nothing is pure 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?

Output schema exists so return values need not be described, yet the description still enumerates returned fields and caps. With annotations covering safety and the description covering cost/caching/rate behavior, an agent has enough to call it correctly; 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?

Single `domain` parameter with 100% schema description coverage ('Domain name, e.g. example.com'). The description adds no format constraints, TLD handling, or normalization rules, so it neither helps nor hurts beyond the schema baseline.

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 (TLS certificates for a domain) and names the data source (Certificate Transparency logs via CertSpotter), which implicitly distinguishes it from the live-check sibling `ssl`. It does not explicitly say how it differs from `subdomains` or `ssl`, so a little inference is required.

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 guidance. The description never tells the agent to prefer this over `ssl` (live TLS check) or `subdomains`, despite clear overlap with both siblings. Only operational constraints (one request per call, cached an hour) 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 cover the safety profile (readOnlyHint, openWorldHint), and the description adds genuinely non-obvious behavior: a $0.004 USDC charge via x402 on Base/Solana/Arc, charged only on success. That cost and payment-rail disclosure is exactly the extra context an agent needs before invoking, though rate limits and latency are not mentioned.

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: capability and model first, then the pricing/charging policy. Front-loaded and every clause 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 0 required parameters and an output schema present, the definition doesn't need to explain return values. It covers what the tool does, the model, the output cap, and the cost model, which is enough to call it correctly; only comparative routing guidance 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 description coverage is 100%, so the schema already documents prompt, messages, max_tokens, and temperature. The description only restates the 1,024 output-token cap already present in max_tokens, adding no new syntax or format detail. 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 (LLM chat completion) and pins the exact model (Llama 3.3 70B), which meaningfully distinguishes it from generically-described siblings like text_answer or summarize. It never explicitly names an alternative tool, 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?

There is no when-to-use or when-not-to-use guidance. In a catalog containing text_answer, summarize, classify, and code_explain, the agent gets no signal about which task this tool is preferred for; the choice between 'prompt' and 'messages' is a parameter decision, 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?

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses the pricing model ($0.002 USDC per successful call), the payment rail (x402 on Base/Solana/Arc), that failed calls are not charged, and that output is model-dependent JSON. Cost and billing behavior are exactly the traits annotations cannot convey.

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

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

Front-loaded with the core operation and constraints before the model/pricing details, and every sentence carries weight (limits, modes, cost). Slightly dense with the parenthetical payment rails, but nothing is wasteful.

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

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

For a 4-param, required-labels tool with an output schema present, the description covers the operation, input limits, output shape (confidence, reason), model dependency, and full cost/payment terms. An agent has everything needed to invoke and price the call.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning beyond the schema: it clarifies the exclusive-vs-multi label mode ('one label per text, or several with multi true') and that each text returns a confidence 0-1 plus a one-line reason. It does not explain text vs texts redundancy, keeping it just above baseline.

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 ('labels up to 20 texts') with concrete operating constraints (2-20 labels you choose, one or several per text). The mechanism of user-supplied labels implicitly distinguishes it from fixed-scheme siblings like sentiment or moderate, so an agent can tell what this does 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?

Usage is implied by the operational detail (you supply the labels; use multi for several per text), but there is no explicit when-to-use vs alternatives, no mention of sentiment/moderate/text_keywords as siblings to route around, and no preconditions. Adequate but leaves routing to inference.

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

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

Beyond the annotations (which already declare readOnlyHint and openWorldHint), it discloses the payment model: $0.002 USDC per successful call via x402 on Base/Solana/Arc, with failed calls not charged. It also adds a 'not medical advice' disclaimer an agent can relay. Cost, payment rails and failure-charge behavior are exactly the kind of non-structured context that matters.

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

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

Two front-loaded sentences with clear priority (what it returns, then disclaimer, then price). The enumeration of return fields is somewhat redundant given an output schema exists, costing a little density, but nothing is confusing or padded.

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

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

For a read-only search with full schema coverage and an output schema, the description covers purpose, filters, cost and a disclaimer adequately. It does not note pagination/limit behavior or result ordering, minor gaps given the structured fields already present.

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 q/limit/phase/status are already fully documented. The description reinforces that matching is by words and filtering is optionally by status and phase, but adds no syntax or format detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific action (search clinical trials) against a named source (ClinicalTrials.gov), with the matching and filtering facets (words, status, phase). The domain and data source clearly separate it from indext siblings like pubmed, fda_label and fda_adverse_events, so an agent can pick it 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 conveys the gist of when to reach for it (looking up trials by keywords, optionally narrowing by status/phase), but there is no explicit when-not guidance and no sibling alternatives named (e.g. pubmed for literature vs clinical_trials for trials). 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?

Even with readOnlyHint and openWorldHint declared, the description adds substantial behavior: truncation of out-of-snippet line numbers, a model-written caveat that findings are leads rather than verified defects, and a full pricing/charging model (x402, USDC, failed calls not charged). This goes well beyond what the annotations convey.

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

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

Front-loaded with the verb and a dense but useful list of outputs, followed by edge-case behavior and pricing. Every clause carries information, though the single long sentence is heavy; structure is good but not maximally scannable.

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 the description still covers scope, input limit, edge-case handling, model-reliability caveat, and cost. Nothing an agent needs to invoke 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?

Schema coverage is 100%, so both parameters are already documented in the schema. The description restates the 20,000-character cap and the language-detection fallback but adds no syntax or format detail 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?

States a specific verb (explains) and resource (code snippet), then enumerates exactly what the output contains: detected language, summary, step-by-step explanation, functions/classes, bugs and security issues with line numbers. No sibling tool overlaps this space, so the agent can identify it immediately.

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

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

Usage is implied by the output enumeration and the 20,000-character limit, but there is no explicit 'use this when...' framing and no named alternative. A reader infers it's for analyzing a code snippet, but nothing routes them between this and, say, validate or sql_generate.

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

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

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses that CNPJ check digits are validated before any network call, the ~3 req/s upstream rate limit, the $0.003 USDC cost via x402 on Base/Solana/Arc, and crucially that failed calls are not charged. That is exactly the operational detail an agent needs before committing a paid call.

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

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

Front-loaded with the purpose and source, then the field list, then the constraints. Dense but every clause earns its place; the parenthetical field enumeration is slightly list-like but useful for an agent matching fields to a user request.

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 not be explained, and the description still covers cost, payment rail, rate limit, input validation, and billing behavior on failure. Nothing material is missing for a single-parameter paid lookup tool.

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

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

Schema coverage is 100% and the single cnpj parameter already documents the 14-digit format with and without punctuation, so the description adds no parameter meaning beyond the schema. Baseline 3 applies when the schema fully carries the load.

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

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

States a specific verb and resource ('Returns Brazilian company data'), names the upstream source (BrasilAPI, CNPJ lookup) and enumerates the returned fields, so an agent can distinguish it from company_fr, uk_company, and generic company_registry calls by jurisdiction alone.

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

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

Usage is only implied: the CNPJ parameter and the field list make clear it is for Brazilian entity lookups, but it never says when to prefer it over company_fr, company_registry, or sanctions/lei tools, nor any prerequisites beyond a valid CNPJ.

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 and openWorldHint, which are consistent with the description. The description adds substantial behavioral context beyond annotations: rate limit (~10 req/s), price ($0.003 USDC per successful call), payment methods (x402 on Base, Solana or Arc), and the fact that failed calls are not charged.

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 purpose and is generally efficient. However, the long enumeration of return fields is partly redundant because an output schema exists, slightly reducing conciseness.

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 external search tool, the description covers purpose, data source, rate limit, cost, payment details, and charging policy. With a full output schema and 100% parameter coverage already present, no critical gaps remain 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 both parameters. The description adds only a redundant 'limit max 25' and no extra syntax or meaning for q, making a baseline 3 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 (Searches) and resource (French companies) and names the official data source (recherche-entreprises.api.gouv.fr). This clearly distinguishes it from generic company_registry or country-specific siblings like company_br and uk_company.

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 no explicit when-to-use or when-not-to-use guidance relative to alternatives. It implies French company lookups but never names or contrasts with sibling tools such as company_registry or company_ticker.

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

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

Annotations cover only readOnlyHint and openWorldHint, but the description adds decisive behavioral context the annotations lack: the $0.003 USDC per-successful-call price, the x402 payment rails (Base, Solana, Arc), and that failed calls are not charged. That payment/charging disclosure is essential operational context for an agent.

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?

Dense but well front-loaded: countries and search modes come first, then return fields, sibling routing and pricing. Slight redundancy with the schema on ID formats costs a point, but 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 present, the description needn't detail return values, yet it still summarizes them; it covers country coverage, search vs. lookup modes, the Poland restriction, sibling routing for France, and the payment model. Nothing an agent needs to invoke 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?

Schema description coverage is 100%, so both q and id formats are already fully documented in the schema. The description largely restates those formats (Norway 9 digits, Y-tunnus, IČO, KRS) rather than adding new meaning, 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 resource (official company registers) and scopes it precisely to Norway, Finland, Czech Republic and Poland, which cleanly distinguishes it from sibling tools like company_fr, company_br, uk_company and lei. An agent can immediately tell what this tool covers and what it does not.

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 states the two usage modes (search by name for Norway/Finland/Czech; look up by number for all four), flags the constraint that Poland is number-only, and routes France to /api/company/fr. The when-to-use conditions and the alternative are both named.

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

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

Goes well past readOnlyHint/openWorldHint: names the data source and its public-domain status, the one-day cache and trimming, the 10-result cap with prefix-first ordering, the 404 failure mode, and the pricing/payment model (x402, $0.002 USDC per successful call on Base/Solana/Arc, failed calls uncharged). Payment mechanics and failure costing are exactly the kind of pre-invocation context an agent needs.

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 the mapping behavior and then the operational facts. Dense but each clause carries information; the cache/timing detail is the only piece that sits near the edge of necessity.

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 need no explanation. Inputs, match limits, source and coverage boundary, failure semantics, and cost are all present — nothing an agent needs before calling 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 adds value beyond it by clarifying that a name fragment yields up to 10 matches ordered with prefix hits first, and by contrasting exact ticker/CIK matching against fragment matching. It does not add format details such as CIK padding or case sensitivity.

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 chain: maps a ticker / SEC CIK / name fragment to the other two plus the exchange. The scope qualifier 'Covers companies with an SEC ticker only' and the source ('SEC's company ticker file') distinguish it from siblings like company_registry, company_br/company_fr, lei and sec_search without the agent needing to open a 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?

Explicit input forms (exact ticker, exact CIK, or name fragment of 3+ characters, up to 10 matches with prefix-first ordering) and an explicit exclusion ('Covers companies with an SEC ticker only', non-matches return 404). It stops short of naming which sibling to use for non-US or non-SEC-ticker companies, so routing outside the SEC universe is left to inference.

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

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

Annotations only declare readOnlyHint and openWorldHint. The description goes well beyond them: it discloses the paid pricing model ($0.002 USDC per successful call via x402 on Base, Solana or Arc), that failed calls are not charged, and the coverage limitation of the search (only the 250 most recently updated bills). That is exactly the behavioral context an agent needs before invoking a metered 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?

Four tight sentences, front-loaded with source and purpose, then mode behavior, then pricing. Every sentence carries information the agent needs; nothing is redundant with the schema or annotations.

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?

Complete for a 4-parameter, zero-required tool with an output schema. Data source, both invocation modes, search limitations, result contents and billing behavior are all covered, so nothing required 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?

Schema coverage is 100%, so the baseline is 3. The description adds real semantics on top: it constrains what q actually searches (bill titles, only the 250 most recently updated bills), gives a concrete bill identifier format, and notes that a bill lookup returns cosponsor count, committees and up to 30 actions.

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 ('US federal bills from Congress.gov') and clearly delineates its two operating modes: keyword search via q and direct bill-number lookup via bill. An agent can immediately tell what this tool returns in each mode, with no overlap ambiguity against siblings.

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

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

Explains when each mode applies (q for keyword search, bill=hr1234-119 for a specific bill) and gives the key constraint that the API has no full-text search, so q only scans the 250 most recently updated bills. No explicit alternatives or exclusions are named, but the mode selection is 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 declare readOnlyHint and openWorldHint, so the access profile is covered. The description adds meaningful behavior beyond that: the exact pricing model ($0.01 USDC per successful call, failed calls free), the payment rail (x402 on Base/Solana/Arc), and which pages are crawled (home, contact, about, legal). This is genuinely useful operational context.

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: the first front-loads purpose and outputs, the second carries pricing. No redundant or filler text, and the most important information leads.

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 the description still helpfully previews the returned fields. Payment and crawling scope are covered; only explicit usage routing against siblings is absent.

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

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

Schema description coverage is 100% and the single parameter is fully documented ('Website URL or domain'). The description adds only that the input is a domain, which the schema already conveys, 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 ('enrichment') and resource ('company contact'), and enumerates exactly what is returned (emails, phones, social profiles, description, tech stack). This distinguishes it from siblings like domain, entities, and email_check, which do not aggregate contact data from a domain's pages.

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 (supply a domain to get contacts) but offers no explicit when-to-use guidance, no exclusions, and does not name an alternative tool for related tasks. Usage context is inferable but not stated.

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

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

The description states 'Computed in the Worker; no network call,' which directly contradicts the annotation 'openWorldHint: true' (indicating external open-world interaction). This is a significant inconsistency.

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

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

The description is front-loaded with the core purpose, followed by necessary details (field count, supported features, computation context, pricing). Every sentence contributes without redundancy.

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

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

Given the tool's complexity, the annotations, and the presence of an output schema, the description is complete enough for an agent to call it correctly. It covers input format, output content (plain English explanation and next runs), computation context, and pricing model, leaving 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?

With 100% schema description coverage, the baseline is 3. The description adds meaningful detail about the 'expression' parameter (five or six fields, seconds first, names like MON/JAN, and steps), which goes beyond the schema's generic 'Cron expression, 5 or 6 fields'. It does not add much for 'tz' or 'count', but the added value for the main parameter justifies a 4.

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 ('Explains') and resource ('cron expression') and clarifies it lists next runs. It clearly distinguishes itself from sibling tools like timezone or date_calc by focusing on cron syntax parsing.

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

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

The description provides clear context about what the tool does (explains cron expressions, lists next runs) and mentions supported syntax (five/six fields, names, steps). However, it does not explicitly state when to use it versus alternatives or any exclusions, though the purpose is 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 mark this as read-only and open-world, but the description adds substantial behavior beyond them: supported chains, output fields (sanction status, list name, SDN program, source link), the explicit caveat that it never declares an address clean, the informational-only disclaimer, the $0.003 USDC price via x402, and that failed calls are not charged.

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 action and coverage, then layers in output details, caveats, and pricing without wasted words. Each clause contributes useful information for selecting and invoking 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?

With an output schema present, the description need not explain return values, but it still names the reported fields. Combined with chain coverage, caveats, pricing, and payment details, an agent has everything needed to call the tool correctly.

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

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

Schema coverage is 100%, and the single parameter already documents the comma-separated format and maximum of 20 addresses. The description reinforces the 20-address limit but adds no new syntax or meaning beyond what the schema provides, 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?

States a specific verb ('Screens') and resource ('crypto addresses') against a precisely named list (US Treasury OFAC SDN digital currency address list). It also names supported chains and the number of currencies, which clearly distinguishes it from siblings like sanctions, evm_address, or btc_address.

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

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

The description makes the screening context clear: use it to check up to 20 crypto addresses for OFAC SDN sanction status. It does not explicitly name alternative tools such as sanctions or screen_debarment, so it falls short of full when/when-not guidance, but the intended usage is 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?

Adds substantial behavior beyond the readOnly and openWorld annotations: fallback to Kraken or Bitstamp when Coinbase is rate-limited, the source field identifying the venue, pricing per successful call, and no charge on failure. These are important operational details for an agent.

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

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

Front-loads the core purpose and key constraints, then covers fallback behavior and pricing. The disclaimer is minor boilerplate, but otherwise the description is efficient and well-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?

Given that an output schema exists and all parameters are documented in the schema, the description covers everything an agent needs: data source, fallback behavior, ordering, limits, pricing, and charging policy.

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 schema already documents pair, limit, and granularity including defaults. The description reinforces granularity options and the 300-candle limit but does not add syntax or format details beyond the schema.

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

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

States the exact resource (OHLCV candles), the venue (Coinbase Exchange public market data), supported pairs and granularities, and ordering. This clearly distinguishes it from sibling tools like crypto_price, crypto_orderbook, and crypto_indicators.

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

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

Provides clear context for when the tool applies: Coinbase trading pairs, specific granularities, and a maximum of 300 newest-first candles. It does not explicitly name alternatives or exclusions, but the scope is clear enough to guide selection.

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

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

Although annotations already declare readOnlyHint and openWorldHint, the description adds substantial operational context: Coinbase as the primary source with Kraken as fallback, pair paths direct or through USD, rate timestamp, and that failed calls are not charged. It also discloses the $0.002 USDC x402 payment model and states the tool is information only, not financial advice.

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 conversion purpose and is dense with useful operational detail. Some clauses are packed into long sentences, but nearly every clause contributes to correct invocation, pricing awareness, or scope boundaries.

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-format explanation is not strictly required, yet the description still covers the key returned elements: rate, converted amount, pair path, and time. Combined with source fallback, payment, and exclusion details, it is complete enough for an agent to call the tool correctly.

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

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

The input schema has 100% description coverage, documenting from, to, and amount including symbol examples and the amount default. The description does not add much parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: convert an amount between a crypto and a fiat currency, or between two crypto assets, at the current spot price. It also names what it is not by refusing fiat-to-fiat conversion and directing that use case to the FX tool, so an agent can distinguish it from siblings.

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

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

The description gives clear usage context, including that it returns a spot rate rather than an executable quote, with no fees or slippage. It explicitly excludes fiat-to-fiat conversion and names the alternative tool for that case, leaving little ambiguity about when to select this tool.

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

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

Annotations cover only readOnly and openWorld, so the description carries the important extras itself: a per-call cost of $0.002 USDC, the x402 payment rails (Base, Solana, Arc), and the crucial detail that failed calls are not charged. That cost-and-failure policy is genuinely decision-relevant for an agent, though rate limits or data freshness/lag are not mentioned.

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 capability is stated first, followed by attribution, disclaimer, and pricing — a sensible front-loading order. The pricing sentence is dense with parenthetical payment rails but every clause (attribution, non-advice, price, free-on-failure) carries distinct 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 an output schema present, return values need not be explained, and the billing model—the main risk for an autonomous caller—is fully disclosed. Coverage is solid for a one-parameter read tool; only freshness/latency and sibling disambiguation are 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 description coverage is 100% and the single 'days' parameter is fully documented as '1 to 30 days (default 1)'. The description only restates the upper bound ('up to 30'), adding no format or edge-case 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?

The description names a specific resource (the Crypto Fear & Greed Index) with a clear scope ('today and for the previous days, up to 30') and output content (classification from extreme fear to extreme greed). It does not distinguish itself from nearby siblings like crypto_indicators or sentiment, which likely also return market sentiment-style data.

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

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

Usage is only implied: an agent can infer this is the tool for historical fear/greed readings, but there is no statement of when to prefer it over crypto_indicators, sentiment, or macro readings, and no exclusions. The remaining sentences cover attribution, disclaimer, and billing rather than selection 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 only cover read-only and open-world; the description adds substantial operational context beyond them: unlisted venues are omitted and reported in 'unavailable', rates are as published by venues, funding is paid between traders not to the venue, data is information-only, and the call costs $0.002 USDC via x402 with failures not charged. Cost, failure behavior and edge-case handling are all 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?

Front-loaded with the returned fields, then edge cases, then pricing — a sensible ordering with no redundant sentences. It is on the long side and the 'not financial advice' line is boilerplate, but every other sentence carries information.

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

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

With an output schema present, return values need no explanation, and the description still covers coverage gaps (unavailable venues), data provenance, and billing. The only missing piece is explicit routing guidance versus sibling tools like crypto_price or perps_markets.

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 sole parameter is documented with format and examples ('2 to 10 letters or digits, e.g. BTC, ETH or SOL'). The description only restates 'one coin' without adding format or venue-specific ticker conventions, 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 (perpetual futures funding for one coin) and enumerates exactly what is returned: funding rate, interval, annualised rate, next funding time, open interest in coins/USD, mark or oracle price. It also names the four venues, so an agent can distinguish it from crypto_price (spot) or perps_markets (market listings) 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?

Scope is clear (one coin, funding data, multi-venue), which implies the use case, but there is no explicit when-to-use or when-not statement and no sibling named as an alternative. The agent must infer that this is the funding-specific tool rather than e.g. crypto_price or perps_markets.

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

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

Beyond the readOnlyHint annotation, the description discloses the data source (Coinbase), a material freshness caveat (the newest candle may still be forming), the pricing model ($0.002 USDC per successful call via x402, failed calls uncharged), and a non-advice disclaimer. These are exactly the behavioral traits annotations cannot carry.

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 purpose is front-loaded before the indicator details and caveats. It is a long, dense run-on, but nearly every clause earns its place (indicator set, source, freshness, pricing). The disclaimers and payment detail could be tightened slightly.

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 explanation. The description nonetheless supplies everything else an agent needs to call it correctly: the computed indicator set, the candle source and granularity range, data-freshness behavior, and the billing model.

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, and the description largely restates defaults (SMA 20/50/200, EMA 12/26) already in the schema. It adds minor value by framing limit as 'candles used for the computation' and naming the RSI/MACD/Bollinger/ATR conventions, but this is baseline territory.

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 (compute technical indicators) and resource (one crypto pair and interval), then enumerates exactly which indicators and periods it returns. This clearly separates it from crypto_candles (raw bars) and crypto_price (spot quote), even without naming 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?

Usage is implied by the indicator list, so an agent can infer 'use this when you need technical analysis,' but there is no explicit when-to-use, when-not, or routing to alternatives like crypto_candles or crypto_price. Context is present but no guidance or exclusions.

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

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

Goes well past the readOnlyHint/openWorldHint annotations: 5-minute feed caching, degradation behavior ('a feed that fails is listed in unavailable'), and the full payment contract ($0.002 USDC per successful call via x402 on Base/Solana/Arc, failures not charged). For a paid, networked read tool this is exactly the behavioral context an agent needs.

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?

Content is front-loaded (sources -> fields -> filtering -> caching -> pricing) with no filler sentences. It is delivered as one dense run-on string, which slightly hurts scannability but wastes nothing.

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 paid, multi-source scraper with an output schema present, the description covers the source set, return fields, filtering, caching/failure semantics, and cost model. Nothing an agent needs to decide or invoke correctly is missing; return-value detail is correctly 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 three parameters; baseline is 3. The description restates the q and coin filters and the 200-char summary cap but adds no syntax, format, or edge-case detail beyond the schema, and omits limit entirely.

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

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

States a specific resource (latest crypto headlines) and enumerates the exact upstream sources (CoinDesk, Cointelegraph, Decrypt, The Block, Bitcoin Magazine), so an agent can distinguish it from general-headline siblings like text_headlines or feed without opening the schema. It also defines the returned shape up front.

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 for use ('Filter by words in the text (q) or by coin') and draws a scope boundary ('Headlines and links only, not the articles'), which tells the agent when this tool is insufficient. It stops short of naming an alternative tool for full-article text or non-crypto news, so no explicit exclusions/routing.

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

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

Annotations only declare readOnlyHint and openWorldHint, yet the description adds the exact cost ($0.002 USDC per successful call), the payment rails (x402 on Base, Solana, Arc), the fact that failed calls are not charged, and the snapshot/non-advisory nature of the data. These are material operational traits an agent cannot get from structured fields.

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

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

Front-loads what the tool returns before the caveats, and every sentence carries information (return shape, snapshot semantics, pricing). It is a dense four-sentence block, but there is little 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 no explanation, and the annotations cover the read-only/open-world safety profile. Combined with the cost, payment and freshness disclosures, an agent has everything needed to decide and invoke correctly.

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

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

Schema coverage is 100% and both parameters are already documented there (pair as Coinbase product, depth 1-50 default 10). The description only restates the depth ceiling ('up to depth 50') without adding format or interpretation guidance, so 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?

Names a specific verb+resource (level-2 order book snapshot for a Coinbase pair) and enumerates exactly what it returns: best bid/ask, mid, spread in price and bps, top levels. This clearly separates it from siblings like crypto_price, crypto_candles and pm_orderbook.

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 implies usage by framing itself as a snapshot rather than a quote and warning that prices move between calls, which tells the agent it is a point-in-time read. However, it never names an alternative tool (e.g. crypto_price for a single quote or crypto_candles for history), so the routing decision is left largely to inference.

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

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

Adds substantial context beyond the readOnly/openWorld annotations: a 15-second cache, the behavior that unpriced symbols land in 'unavailable' rather than erroring, a per-price source attribution, and a concrete cost model ($0.002 USDC per successful call via x402; failures are free). The payment requirement is exactly the kind of trait an agent must know before invoking.

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?

Dense but front-loaded: capability first, then edge-case behavior, then cache/cost. Nearly every sentence earns its place; the 'Information only, not financial advice' clause is the one near-filler line, though it is arguably relevant to an agent relaying prices.

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 still covers source attribution and the 'unavailable' bucket. Combined with cache TTL, provider selection, and x402 payment terms, an agent has everything needed to decide, pay, and interpret results.

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

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

Schema description coverage is 100%, so the single 'symbols' parameter is already fully documented (comma-separated, up to 20, Solana mint addresses accepted). The description largely restates this, adding only the fallback behavior for symbols with no price. Baseline 3 is appropriate.

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

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

States a specific verb+resource ('USD spot prices'), quantifies the batch ('up to 20 symbols') and names the data sources (Coinbase for symbols, Jupiter for Solana mints). This clearly separates it from sibling tools like crypto_candles (OHLC history), crypto_convert (conversion) and solana_quote (single-mint dex quote).

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 batch-of-20 and 'USD spot' framing implies when this tool is the right pick, but the description never explicitly routes the agent to or away from alternatives such as crypto_candles, crypto_convert or solana_quote. There are no stated exclusions or prerequisites for use.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description discloses pricing ($0.003 USDC per successful call via x402 on Base/Solana/Arc), that failed calls are not charged, that sender/receiver labels are null for most addresses, and that the data window is constrained by a single RPC read. These are material traits an agent cannot derive from the annotations.

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

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

One dense paragraph that front-loads the purpose before pricing and caveats; nearly every clause carries information. It is slightly packed with mixed concerns (data shape, cost, freshness) but wastes no sentences.

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

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

With five parameters fully documented in the schema, an output schema covering the return shape, and the description adding cost, payment rails, label nullability and freshness limits, an agent has everything needed to call this correctly and predict the outcome.

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 defaults, ranges and per-chain block limits; baseline is 3. The description adds only marginal meaning ('where the chain has it' for tokens, Coinbase spot price for USD valuation) and does not override the schema's work.

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: large stablecoin/major-token transfers in the last few minutes across five named chains, with the returned fields (hash, block time, sender, receiver, amount, USD value) enumerated. An agent can immediately tell this apart from general tools like evm_transfers or crypto_candles.

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 ('last few minutes', 'sorted by value', 'one token contract read over public RPC, so the window is short'), but the description never states when to pick this over alternatives such as evm_transfers or crypto_orderbook. The 'information only, not financial advice' line is a disclaimer, 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?

Goes well beyond the readOnly/openWorld annotations: it discloses deterministic 'pure code' execution, month-end clamping on add/subtract, the failure mode ('impossible dates are a 400 with the reason'), and the billing model ($0.002 USDC per successful call, failed calls not charged). Pricing and failure semantics are exactly the non-obvious traits an agent needs before calling a paid endpoint.

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

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

Front-loaded with the core purpose, then a compact op-by-op enumeration, then error and pricing notes — every sentence carries information an agent needs. It is a single dense paragraph, so the op list and the billing note are harder to scan than they would be as separate lines.

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 11 parameters and an output schema (so return values need no explanation), the description covers all five operations, failure behavior and cost, which is nearly everything needed to call it correctly. The remaining gaps are DST handling for tz and disambiguation from the timezone/business_days siblings.

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 genuinely new semantics: the allowed op set, default unit behavior, defaults implied by 'asOf', and the clamping rule that applies to amount/unit combinations. It does not clarify DST/ambiguous local times for the tz op, which is the one parameter area the schema is silent on.

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 ('date and time calculations in pure code') and then spells out exactly what each of the five ops does, so an agent can pick the right operation. It does not, however, distinguish itself from overlapping siblings such as timezone, business_days, holidays or cron, which is a real ambiguity for op=tz.

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?

Each op is given a concrete use case (diff = elapsed calendar time, add/subtract = shift a date, info = weekday/ISO week/age, tz = convert between IANA zones), which effectively tells the agent when to choose which op. There is no when-not guidance or pointer to alternatives, notably for op=tz versus the timezone sibling tool.

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

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

Annotations only cover readOnlyHint and openWorldHint, so the description carries real extra weight: it discloses the data provider (DefiLlama), the billing model ($0.002 USDC per successful call via x402 on Base/Solana/Arc), and critically that failed calls are not charged. That charge/failure semantics is exactly the kind of behavior an agent needs before calling and is not derivable from structured fields.

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

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

Front-loaded with the core purpose and result shape, then mode behavior, then data source and billing. Dense but orderly. The 'Information only, not financial advice' sentence is boilerplate that does not help tool selection, a minor bit of padding.

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

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

An output schema exists, so return details are largely covered, and the description still helpfully summarizes the payload. Pricing, provider and the chain/no-chain split are all present. The only real gap is sibling differentiation against defi_tvl and defi_stablecoins.

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 already 100%, so the baseline is 3, but the description adds meaning the schema does not: 'chain' switches the response shape (single row plus 1/7/30-day history) and the ordered-list semantics behind 'limit' (

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 (total value locked by chain from DefiLlama), the sort order (largest first), and the extra fields returned. However it never names or contrasts itself with the obvious siblings defi_tvl, defi_stablecoins or defi_dex_volume, so an agent must infer the boundary between chain-level and protocol-level TVL.

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 does explain the two modes: omit 'chain' to get the ranking, pass 'chain' to get that chain's row plus 1/7/30-day TVL change. That is useful contextual guidance, but there is no explicit when-to-use-this-instead statement relative to the many other defi_* tools, leaving the selection decision to inference.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the per-call price ($0.002 USDC via x402 on Base/Solana/Arc) and, crucially, that failed calls are not charged, which affects invocation risk and retry 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 core data description is front-loaded in one dense sentence, followed by attribution and pricing. Everything present earns its place, though the attribution/legal boilerplate is slightly less essential than the metric scope.

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 the description still summarizes the returned metrics, so return values are well covered. For a one-param read tool with annotations, cost, and attribution stated, the only real gap is sibling differentiation.

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 the single 'protocol' param documented as a DefiLlama slug with an example. The description adds no parameter-level 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?

The description names the resource (a DEX's trading volume) and specifies the exact metrics returned (24h/7d/30d volume, day-over-day change, chains), which is more specific than a tautology. However, it never distinguishes itself from close siblings like defi_tvl or dex_pools, so an agent must infer the boundary.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named. The metric list implies it is the tool for DEX volume data, but the agent gets no help choosing it over defi_tvl or dex_pools.

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 and openWorldHint, so the safety profile is covered. The description does add genuinely useful non-annotation context: a $0.002 per-successful-call charge via x402 on Base/Solana/Arc, with failed calls free, plus a DefiLlama attribution and a not-financial-advice disclaimer. That is real added value, though nothing is said about rate limits, quotas, or freshness/latency of the data.

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 return contents and time windows are front-loaded, and the pricing/attribution boilerplate is compact and separated from the functional sentence. Slightly dense in the first sentence, but no wasted prose.

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

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

An output schema exists, so return shapes need not be restated, yet the description still previews the metric set helpfully. Combined with the disclosed paid-call model and attribution, an agent has what it needs to call this correctly; only cross-tool routing guidance is absent.

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

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

Only one parameter (protocol) and the schema description coverage is 100%, including the slug example 'aave' or 'uniswap-v3'. The description adds no syntax or format detail beyond the schema, so the baseline 3 for high schema coverage applies.

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

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

Names a specific resource (a DeFi protocol's fees and revenue) and enumerates the exact metrics returned: 24h/7d/30d windows, day-over-day change, and supported chains. That is enough to separate it from defi_tvl or defi_dex_volume, though it never names those nearby siblings explicitly, so an agent must still infer the boundary.

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 pick this over the numerous adjacent DeFi tools (defi_tvl, defi_dex_volume, defi_chains, defi_yields). The only usage-relevant content is the payment model, which tells the agent it costs money but not when spending it is appropriate.

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

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

Beyond the readOnly/openWorld annotations, it discloses the cost model ($0.002 USDC per successful call, x402 on Base/Solana/Arc), that failed calls are not charged, and that attribution to DefiLlama is expected. Payment mechanics and failure-charging behavior are exactly the kind of operational detail annotations cannot convey.

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

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

Front-loaded data scope followed by mode behavior, attribution, disclaimer, and pricing. Every sentence carries information, though 'Information only, not financial advice' is boilerplate that could be trimmed without losing call-relevant meaning.

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 optional parameter, an output schema, and read-only annotations, the definition covers what is returned, the default scope, and the cost of a call. It omits how to retrieve stablecoins beyond the top 50 (pagination or ranking criteria), which is the one gap an agent might hit.

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 optional parameter is documented in the schema, so the baseline is 3. The description adds real semantic value by specifying the default result set (the 50 largest) when symbol is omitted, which the schema does not state.

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 concrete resource (stablecoins tracked by DefiLlama) and enumerates the returned dimensions: circulating supply, peg type and mechanism, price, and supported chains. That is enough for an agent to separate it from defi_tvl, defi_chains, or crypto_price, 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?

'With symbol, that coin; without it the 50 largest' gives clear mode-selection guidance between the two call patterns. It stops short of telling the agent when to prefer this over crypto_price (live quotes) or token_metadata (token details), so usage is implied rather than routed.

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

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

Annotations only declare readOnlyHint and openWorldHint. The description adds pricing ($0.002 USDC via x402 on specific chains), that failed calls are free, attribution, and that protocol results omit change figures. That's real behavioral context beyond annotations, though it omits rate limits and the fact that no parameters returns something ambiguous.

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

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

Front-loads the core purpose well, but the pricing, attribution, and disclaimer clauses add bulk that pushes the important operational constraint (no history) into a buried middle sentence.

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

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

Covers the two input modes, the protocol-vs-chain output difference, cost mechanics, and attribution. With an output schema present and 100% schema coverage, remaining gaps are minor; ambiguity about zero-parameter calls is the main omission.

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

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

Schema coverage is 100% and the schema already documents both params, but the description usefully clarifies the protocol path yields only current TVL while the chain path yields 1d/7d changes, adding meaning about output shape.

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

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

States a specific verb+resource: returns total value locked in DeFi from DefiLlama, and distinguishes inputs (protocol slug vs chain name). Clearly separable from siblings like defi_chains, defi_dex_volume, defi_fees, defi_stablecoins.

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 what each parameter class fetches and explicitly notes that a protocol's history is too large to read here, which is a useful boundary. However, it doesn't point to which sibling to use for historical TVL or chain lists.

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

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

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses the $1M TVL floor, the 50-result cap, that APY is a DefiLlama estimate split into base and reward with often-temporary reward APYs, plus the exact cost model ($0.002 USDC per successful call via x402, failed calls free). The data-reliability caveat and billing behavior are exactly the kind of context annotations cannot carry.

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

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

Purpose and constraints are front-loaded in the first sentence, followed by data-quality caveats and billing terms. It is dense and semicolon-heavy with some mandatory legal/attribution boilerplate, but every clause carries actionable information and none 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?

With an output schema present and annotations covering the safety profile, the description supplies cost, scope, result cap and APY caveats, which is nearly everything an agent needs. The one small gap is that 'sorted by APY' does not state direction, and multi-value filter behavior is unaddressed.

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 five parameters are already documented in the schema. The description restates chain/project/symbol filtering and the $1M TVL floor without adding syntax or format detail 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?

States a specific verb and resource ('DeFi yield pools from DefiLlama') and pins down the key scoping constraints: minimum $1M TVL, sorted by APY, filtered by chain/project/symbol, capped at 50. This is clearly distinguishable from siblings like defi_tvl, defi_stablecoins or dex_pools without opening any 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 implies when the tool is useful (yield/APY discovery filtered by chain, project or symbol) but never states when to prefer it over related siblings such as defi_tvl or dex_pools, nor any exclusions. Usage is inferable but not spelled out.

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

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

Goes well beyond the readOnly/openWorld annotations: it names the underlying model (Llama 3.2 11B Vision), warns that answers can be wrong, states the exact cost ($0.003 USDC per successful call), names the payment rails (x402 on Base, Solana or Arc), and clarifies failed calls are not charged. Cost and reliability disclosures are exactly the context annotations cannot convey.

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

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

Inputs are front-loaded in the opening clause, with output contents, model caveat and pricing following in a tight sequence of semicolon-joined clauses. Dense but every clause carries distinct information; slightly long single sentence costs it 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?

Even though an output schema exists (so return values needn't be described), the description covers inputs, formats, size limit, output shape, model identity, accuracy caveat and billing. For a 3-parameter, non-nested tool this leaves nothing an agent needs to decide or pay correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: 'url' must be https, 'image' is the base64 alternative, accepted formats and the 4 MB ceiling, and that 'question' is optional and answered rather than merely passed through. These constraints are absent from the schema descriptions.

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 ('Describes an image from an https URL or base64') and then enumerates the exact outputs (short description, visible objects, text presence, optional question answer), so an agent knows precisely what it gets. The supported formats and 4 MB cap further pin down scope versus generic image/vision siblings.

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

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

Usage is only implied by the input formats and the optional 'question' parameter; there is no explicit when-to-use statement and no mention of alternatives such as ocr (pure text extraction) or image/logo tools in the sibling list. An agent can infer the use case but gets no 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 only declare readOnlyHint and openWorldHint, but the description adds substantial undisclosed behavior: the x402 payment mechanism ($0.002 USDC per successful call, Base/Solana/Arc) and the crucial billing rule that failed calls are not charged. This is exactly the kind of cost/failure semantics an agent cannot infer from structured fields.

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

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

Front-loads purpose, then return fields, then constraints and cost. Mostly efficient, though the long enumeration of returned fields overlaps with the existing output schema and adds some length.

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 readOnly/openWorld annotations and a dedicated output schema, the remaining agent-relevant unknowns are cost and failure billing, both fully disclosed. Nothing needed to invoke the tool 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 description coverage is 100%, so chain, limit, and token are already documented; the description only restates the 'up to 30' limit that the schema already carries. 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?

States a specific verb (fetches) and resource (DEX liquidity pools) scoped to a token or pair across chains, and names the data sources (DexScreener with GeckoTerminal fallback). This clearly separates it from sibling market tools like defi_dex_volume, token_metadata, or crypto_price.

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 for when to call it ('for a token or pair across chains') and the practical ceiling (max 30 pools), but never names an alternative sibling or states when NOT to use it (e.g., aggregate DEX volume via defi_dex_volume). Clear usage, missing explicit exclusions.

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