x402 Bazaar

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

Annotations already cover safety (readOnlyHint=true, idempotentHint=true, openWorldHint=true), so the burden is lowered. The description adds the crucial scope (28-day lookback, weekly transfer counts + distinct participants), an output-vocabulary, and payment behavior (x402 on Base, prepaid x-headers, 1 free call/day, no API key). It does not, however, describe return structure, rate limits, or edge cases (e.g., very new tokens), so it sits at a 3.

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 long and absorbs unrelated material — pricing, x402 payment instructions, free-call quota, 'Not financial advice.' For an agent selecting a tool, this dilutes the signal. Sentences are hard-hitting early but the tail is logistics (payments) that belongs in a payment/context field, not in the core purpose statement.

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-address, read-only analytic with an output schema present, the description supplies the missing conceptual frame (adoption trajectory vs. price, five output labels, 28-day window) that an agent needs to interpret the result. It omits the exact return structure, which is fine because an output schema exists, and it omits error/threshold semantics for the low_activity bin. Close to complete.

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 (address), schema coverage is 100% and the description restates 'Required input: address', which is redundant with the schema. Because the schema already fully documents the parameter, baseline is 3; the description's added value is elsewhere (output labels, payment model), so a 4 rather than 5 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 analytic — reads weekly transfer counts and distinct participants over 28 days and classifies adoption trajectory into five states. It explicitly distinguishes itself from token-age (birth timestamp) and holder-distribution (static snapshot), and names the concrete output labels. Only the specific parameter/return shape keeps it from a clean 5.

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

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

It draws a sharp line versus price-oriented siblings (token_momentum, wash_trading) and against static-holder siblings (token_age), and explicitly tells the agent to pair with wash-trading. Strong routing. No explicit 'when NOT to use' for the analytic-vs-snapshot class beyond the sibling contrasts, so not a clean 5.

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

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive, openWorld), but the description adds information none of them carry: $0.002 per call via x402 on Base, the prepaid x-credit-token header for unlimited calls, 1 free call/day per tool, and no API key required. That is exactly the auth/cost/rate-limit 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?

Front-loaded with the core purpose and the key exclusion before pricing details, and every clause carries information. The dash-separated phrasing is dense and slightly repetitive ('Structural address check: country, street, city' restates the opening), but it stays compact overall.

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

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

An output schema exists, so return values need not be explained, and the description still sketches them lightly ('normalised single-line form and named issues'). Cost, auth and the deliverability caveat make it largely self-sufficient; the country coverage stays vague ('common countries', '…') without saying what happens for unsupported countries, which is the one remaining gap.

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

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

Schema description coverage is 100% for all five parameters, so the schema already documents country (ISO-2), line1/line2, city and postal. The description restates the required set (country, line1, city) and the covered country set, but adds no format or syntax detail beyond 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 and resource: a structural postal/address format check covering country, street, city and postal patterns, naming the covered regions (TR, US, GB, DE, FR, NL). It also explicitly draws the boundary that separates it from validation-type siblings by saying it is 'Not proof of deliverability', so an agent can place it against address_intel, address_trust and address_label.

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 a clear usage moment ('before you ship') and an explicit exclusion ('Not proof of deliverability'), which prevents the common misread of this as a deliverability validator. It does not name a specific sibling alternative, so it stops short of full when-to-use/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?

Beyond the annotations (readOnly, idempotent, openWorld, non-destructive), the description discloses the data source (Base RPC), the payment model ($0.02/call via x402 on Base), the auth alternatives (prepaid x-credit-token header for unlimited calls, or 1 free call/day), and that no API key is required. This is exactly the operational context 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?

The core capability and its outputs are front-loaded in the first clause, followed by use case, input requirement, and pricing/auth in descending priority. Every sentence carries distinct information with no filler.

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

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

An output schema exists, so return-value documentation is not required, and the description still previews the key returned fields. Combined with the explicit input requirement and the pricing/auth details, nothing an agent needs to invoke this 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?

There is a single parameter with 100% schema description coverage, and the description only restates that address is the required input ("Required input: address"). No format hints (hex vs ENS), chain qualification, or validation rules are added beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific resource (any Base address) and enumerates concrete outputs: EOA vs contract classification, ETH + USDC balance, transaction count, and activity level. That field-level detail makes it distinguishable from generic siblings like address_label or address_check. It stops short of naming or contrasting an explicit sibling, so it is clear but not fully differentiated.

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?

"Useful for counterparty and wallet checks" gives an implied use context but names no alternatives (e.g., address_trust, address_label, counterparty_check) and states no exclusions or prerequisites. Usage is inferable from the described outputs rather than explicitly guided.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the description isn't needed for the safety profile. It adds real value beyond that: it discloses the key behavioral guarantee that unmatched addresses are reported as unlabelled and never guessed, plus the pricing model ($0.005/call over x402, prepaid header for unlimited, 1 free call/day, no API key).

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 with a punchy framing sentence, then layers mechanism, guarantee, input, and pricing in a sensible order. Slightly long and the rhetorical question framing costs a little space, but every subsequent 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?

An output schema exists, so return values needn't be spelled out, and the description still explains what it reads and how unmatched cases are handled. For a one-param tool with full schema and annotation coverage, this is nearly complete; only sibling differentiation 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% for the single parameter, so the schema already documents 'address'. The description merely restates 'Required input: address' without adding format, checksum, or chain constraints. 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?

The description states a specific verb+resource — 'label / identify what this Base address is' — and details the mechanism: matching a sourced registry and reading chain state (contract vs EOA, ERC-4626, Safe, DEX pool). It is clearly distinct from a generic lookup, but it never explicitly names or contrasts with near neighbors like address_intel or address_check, which is what would earn a 5.

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

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

Usage is implied rather than stated: the agent can infer 'use this when you have an unknown Base address and want to know what it is.' There is no explicit when-to-use, when-not-to-use, or alternative-tool routing despite numerous sibling address tools that overlap in surface area.

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 read-only, idempotent, non-destructive, open-world, but the description adds substantial extra context: it is a heuristic that must be verified, it compares against head/tail of addresses the wallet actually transacts with, and it discloses the pricing/rate-limit model ($0.03/call via x402 on Base, prepaid header, 1 free call/day, no API key). That goes well 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?

Front-loads the core question effectively, but the body carries promotional and disclaimer filler ('An auto-paying agent is the perfect victim', 'Not financial advice') and pricing detail that dilutes an otherwise compact definition. Several sentences repeat what the annotations and schema already state.

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 covers the attack model, required inputs, heuristic caveat, and payment mechanics. It is complete for invocation; only minor ambiguity remains about how 'near-miss' results should be acted on.

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

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

Schema coverage is 100% with only two documented params, so the schema already carries the meaning. The description restates them ('Pass wallet= (yours) and to= (the recipient)') and adds the 'sender' framing, but provides no format or validation detail beyond the schema. 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 check ('is this recipient a look-alike trap') on a specific resource (recipient address) and explains the attack it detects via head/tail matching against real counterparties. Clearly separable from siblings like address_check, safe_to_send, or pre_trade_gate because it names the exact heuristic and scenario.

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

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

Explicitly says to run it 'before your agent pays' and that an auto-paying agent is the target victim, and instructs passing wallet= (yours) and to= (recipient). It gives clear situational context but does not name alternative sibling tools (e.g., address_trust, counterparty_check) for cases where the check is inconclusive.

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

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

Annotations already cover read-only, idempotent, open-world, non-destructive, but the description adds material context beyond them: exact pricing ($0.03/call via x402 on Base), the prepaid x-credit-token header for unlimited calls, the absence of a free tier, and that no API key is required. It also cautions that identity is a signal, not proof of honesty, which is genuinely useful behavioral framing.

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

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

The lead question is front-loaded and immediately scannable, and each subsequent clause adds a distinct fact (mechanism, output, pairing, pricing). It is dense and slightly long, but no sentence is filler, so it lands just under a 5.

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

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

With an output schema present, return values need not be spelled out, and the description still summarizes the verdict shape. Combined with pricing, auth mechanism, and the honesty caveat, an agent has everything needed to call it correctly and interpret the result.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents 'address'. The description's 'Required input: address' only restates the schema's required field and adds no format, chain, or validation detail, so the baseline of 3 applies.

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

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

The description names a specific verb and resource — a Coinbase-verified-vs-anon/sybil verdict plus Basename for an address — and pins down the mechanism (EAS attestation by verifications.coinbase.eth) that separates it from generic siblings like address_check, address_label, or address_intel. An agent can tell exactly what this returns 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?

It frames the use case sharply ('the who am I dealing with? check for agents') and tells the agent to pair it with sign-guard/spend-audit for a full pre-transaction gate, which is explicit routing guidance. It lacks a when-not-to-use statement (e.g., versus counterparty_check or address_intel), so it stops short of a 5.

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

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

Adds substantial context beyond annotations: the one-verdict output model, the specific screening signals, the $0.01/1-free-call-per-day pricing over x402, and the x-credit-token header auth path. Crucially, readOnlyHint=true is consistent — it screens but does not move funds — so there is no contradiction, and the pricing/auth detail is exactly the kind of operational context 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?

The core facts are present but the prose is dense and marketing-flavored, with a hook opener ('I'm about to pay 0x… $X — go?'), redundant re-emphasis of amount-awareness, and the filler disclaimer 'Identity is not intent; not financial advice.' Several clauses could be trimmed without losing actionable information.

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

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

An output schema exists, so return values need not be explained, and the description still covers screening criteria, pricing, auth, and the verdict set. It would be fully complete with an explicit pointer to the alternative recipient-check tools for non-payment contexts.

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 'to' and 'usd'. The description mostly restates this ('Pass usd= for amount-aware guidance', 'Required input: to') rather than adding new syntax or format detail, landing at the baseline for a fully-covered 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+resource+scope: a pre-payment gate that screens a USDC recipient before an agent sends funds. It names the exact checks performed (OFAC sanctions, Coinbase/Basename identity, wallet vs contract, fresh-address age) and the output (GO/REVIEW/STOP), so an agent can distinguish it from siblings like address_check, safe_to_send, or sanctions.

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?

Clearly establishes the when-to-use scenario ('an agent about to send USDC', escalating fresh/anonymous recipients to STOP once the amount is material) and explains the amount-aware sampling-vs-drain logic. It does not explicitly name alternative siblings (e.g., address_check or pre_trade_gate) or state when NOT to use it, so it falls just short of full routing guidance.

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

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

Goes well beyond the readOnly/idempotent/openWorld annotations: it discloses the 90-day lookback, the Base-USDC-only scope, the crucial interpretive caveat that absence reads as 'thin' and never as bad, and the commercial mechanics ($0.03 per call over x402, prepaid x-credit-token header for unlimited calls, 1 free call/day, no API key). Those are material facts 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 the decision question and the observed signal pattern before the mechanics, which is the right ordering. It is dense but nearly every sentence carries an interpretive or operational fact; the 'Not financial advice' clause is minor filler, keeping it just short of 5.

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

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

With an output schema present, the description need not explain return shape; instead it supplies what the schema cannot: coverage limits (Base USDC only), the time window, how to read a null result, and the payment/auth model. Nothing an agent needs 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 description coverage is 100% and there is a single parameter, so the schema already documents 'wallet'. The description only restates 'Required input: wallet' without adding format, address-vs-ENS, or chain semantics, 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?

Opens with a specific decision question (real repeat customer vs one-shot sampler) and then states exactly what it reads: a wallet's outgoing USDC payments on Base over 90 days, computing breadth, depth, and repeat-payee signals. It explicitly distinguishes itself from its sibling by naming 'the payer-trust mirror of x402-seller-check', so an agent can route without opening either schema.

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

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

Clear context is given for when to reach for it (assessing whether a payer is a genuine repeat customer) and the alternative framing versus x402-seller-check is named. It stops short of explicit when-not conditions or named substitutes for the non-x402 case, so it is strong but not exhaustive.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds high-value invocation context the annotations cannot: paid x402 model, $0.06 per call, prepaid x-credit-token header for unlimited calls, no free tier, no API key. This directly affects how an agent should budget and authenticate calls.

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

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

Front-loaded with purpose and differentiator before the operational details, and the pricing/auth sentence earns its length. Some promotional adjectives ('the agent-era scoped recurring allowance', 'the only combined check') add flavor at the cost of density, keeping it short of a 5 for a one-parameter 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?

Output schema exists, so the verdict payload and revoke queue needn't be described, and annotations cover the read-only profile. Purpose, cost, auth, and required input are all present; only minor edges like chain restrictions or response latency are 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?

With a single parameter at 100% schema description coverage, the schema fully documents 'wallet'. The description only restates 'Required input: wallet' and adds no format detail (e.g., checksummed address expectations, supported chains). Baseline 3 is appropriate since the schema carries the semantics.

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

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

States a specific verb and resource — the combined fund-movement authority on a Base wallet — and enumerates exactly the two surfaces scanned (ERC-20 approvals plus Base Account spend permissions). It explicitly distinguishes itself from sibling categories: 'Approval tools miss the spend permissions; spend-permission tools miss the approvals.' An agent can differentiate it from token_approvals, spend_audit, and revoke_builder without opening 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?

Gives clear context for use — 'agent wallets that must know their whole exposure before holding funds' — and contrasts against alternative approaches by category. It stops short of naming specific sibling tools (spend_audit, token_approvals, revoke_builder) or stating an explicit when-not-to-use condition, so it is strong but not exhaustive.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, and the description adds material context they cannot carry: $0.04 per call over x402 on Base, an x-credit-token prepaid header for unlimited calls, no free tier, and no API key required. Cost and auth requirements are exactly the behavioral 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?

The purpose is front-loaded in the opening clause and every subsequent sentence adds a distinct fact (mechanism, capabilities, cost, auth). It is somewhat dense and em-dash-heavy, with pricing information wedged mid-paragraph rather than separated, but there is little outright waste.

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 safety profile. Between the mechanism, the danger-level output, the required input, and the cost/auth model, an agent has everything needed to select and invoke it correctly.

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

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

There is a single parameter with 100% schema description coverage, and the schema already marks it required. The description's 'Required input: address' restates structured data without adding format or syntax 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 verb and resource: it combines security flags with verified ABI function names and uses AI to explain a contract's dangerous capabilities (mint, pause, blacklist, upgrade, self-destruct) with a danger level. The contrast with 'raw flags' hints at its niche, but it never names the many closely related siblings (contract_danger, owner_powers, token_risk, rug_score), so an agent must infer the boundary itself.

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

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

'Goes beyond raw flags to read what the contract can actually do' implies when to prefer this over raw-flag tools, and the pricing/auth notes tell the caller how it can be invoked. However, no alternative tool is named and there are no explicit when-not conditions, so the routing guidance remains implicit.

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

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

Annotations already declare read-only/idempotent/non-destructive, and the description adds substantial context they cannot carry: 16K char cap, max 10 fields, list-mode array semantics, $0.05 per call over x402, prepaid x-credit-token header for unlimited calls, and no free tier. Payment and quota behavior is exactly the kind of trait 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 transformation leads, followed by the highest-value mechanics (fields, list), limits, and the batch/pricing routing. It is dense and information-packed rather than padded, though the promotional framing ('ANY', 'guaranteed-valid') and stacked pricing sentences cost 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?

An output schema exists so return values need not be described, and for a 3-parameter read-only extraction tool the description covers inputs, limits, cost, auth header, and the batch alternative. Nothing an agent needs 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?

With 100% schema coverage the baseline is 3, but the description genuinely enriches the parameters: fields is capped at 10 and comma-separated, and list=true means 'extract EVERY repeated record as an array' rather than a single object. That 'true vs absent' distinction materially changes the call and is not spelled out in the schema.

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

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

States a concrete verb+resource transformation ('Unstructured text → structured JSON') and names the output guarantee (schema-enforced JSON). It also distinguishes itself from siblings by explicitly denying a crypto-specific scope and pointing to ai-extract-batch for the multi-document case, so an agent can place 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?

Gives concrete usage contexts ('pages, emails, receipts, logs') and names the alternative for a different condition ('Many documents? ai-extract-batch'). It stops short of an explicit when-not-to-use statement beyond that routing hint, keeping it below the top band.

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 the safe-read profile (readOnly, idempotent, non-destructive, open-world), and the description goes well beyond them: exact pricing ($0.10 per call over x402 on Base), the x-credit-token prepaid header, the absence of a free tier, no API key requirement, and a 6K char per-document limit. An agent knows the cost, auth path and size constraints before calling.

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 value proposition and ordered sensibly (what it does, how to call, why batch, limits, price, auth). It is dense and slightly salesy in the per-call cost comparison, but nearly every sentence carries actionable 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 already present, the description need not explain return values and instead states the shape qualitatively ('one schema-enforced JSON object per document, in order'). Combined with pricing, auth, per-document limits and required input, nothing material is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real invocation detail: how to pass multiple documents ('text1=…&text2=… or texts= with ||| separators') and the required text1. Minor friction: the 'texts=' form it advertises does not appear as a property in the input schema, which could send an agent down a wrong path.

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 with explicit scope: batch extraction of the same field list across up to 10 texts. It directly positions itself against the sibling by calling itself 'the pipeline version of ai-extract', so an agent can separate the batch and single-document tools without opening either schema.

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

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

Gives concrete usage contexts ('agents parsing feeds, inboxes, scrape batches and receipt piles') that imply when batching pays off, and referencing ai-extract signals the single-document alternative. It never states an explicit when-not-to-use condition (e.g. use ai_extract for a single document), so the routing is inferable rather than 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?

Beyond the readOnly/idempotent/openWorld annotations, the description discloses cost and access mechanics that structured fields never carry: $0.05 per call over x402 on Base, a prepaid x-credit-token header for unlimited calls, no free tier, and no API key. It also describes the brief's contents and that fresh/unknown tokens are flagged for rug risk.

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 scope are front-loaded in the first clause, and each following sentence carries distinct information (aggregation source, brief contents, pricing, auth). It is a dense single paragraph with heavy em-dash use, which is slightly harder to scan than a structured list, 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, return shape need not be explained, and the description adds the payment/auth model and content summary an agent needs before invoking a paid, no-param tool. Minor gaps remain: how to obtain the x-credit-token and any latency/freshness expectations for a generated brief.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. The description correctly implies the call is self-contained with no filtering inputs.

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

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

States a specific verb and resource ('AI-written situational brief of the Base token market') with explicit scope: aggregates trending and newly-listed Base tokens, then writes mood, highlights, launches, and cautions. This clearly separates it from siblings like market_pulse, trending_tokens, new_tokens, or ai_summarize 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?

'One call gives a trading agent market context instead of dozens of lookups' gives clear usage context and an implicit alternative to per-token lookups. However, it never names a competing sibling tool (e.g. market_pulse or crypto_trending) or states when NOT to use it, so no explicit routing is provided.

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 the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds the operationally critical details those annotations cannot: exact cost ($0.03/call over x402 on Base), the prepaid x-credit-token header for unlimited calls, absence of a free tier, and no API key/prompt engineering required. This is exactly the payment/auth context an agent needs before calling 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?

Front-loaded with the punchline (any text → crisp bullets) and efficiently structured, but there is redundancy: 'No API key' appears twice, and 'one micro-payment per call' is restated as '$0.03 per call'. Minor waste keeps it below a 5.

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

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

An output schema exists, so return-shape detail is unnecessary, and the description covers purpose, input limit, payment/auth mechanics, and pricing. For a single-parameter read-only tool, 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% and the single param is documented, so baseline is 3. The description adds a real constraint absent from the schema — the 16K-character input limit and the 'send text=, get bullets back' calling convention — which meaningfully supplements the bare 'Text to summarize' field.

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: compress any text (up to 16K chars) into 3-5 bullet points, with concrete input examples (articles, transcripts, email threads, reports). The purpose is unmistakable, but no sibling tool (ai_extract, ai_translate, web_extract) is named to distinguish the boundary between summarization and extraction/translation.

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 usage context: 'The digest step for agent pipelines that read more than they can carry in context.' This tells the agent when the tool fits. However, it offers no explicit exclusions or named alternatives (e.g. use ai_extract for structured fields), so the routing guidance stops short of a 5.

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

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

Annotations already carry readOnly/idempotent/openWorld/non-destructive, and the description adds real context the annotations cannot: per-call price ($0.12 via x402 on Base), the prepaid x-credit-token header path for unlimited calls, no free tier, and no API key required. It stops short of noting latency, caching, or rate limits, so it is strong but not exhaustive.

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 capability and payment terms are front-loaded, but marketing filler ('The flagship report', 'agent-ready intelligence you can't get free') consumes sentences that do not help an agent decide or invoke. Trimming the promotional clauses would leave a materially tighter definition.

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 correctly does not enumerate return fields, and it covers cost, auth path, and required input for a one-parameter tool. The remaining gap is explicit routing against sibling report tools, which matters given how many overlapping DD/risk siblings exist.

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

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

The single address parameter is fully documented in the schema (100% coverage) as 'Token contract address', and the description only restates it as 'Required input: address'. Baseline 3 is appropriate when the schema does the heavy lifting; no extra format or chain caveats are added.

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 ('AI-written due-diligence verdict for a Base token') and enumerates the aggregated inputs (token risk, holder concentration, price/liquidity, OFAC sanctions) plus the output shape (avoid → favorable). It does not name which sibling report tools it supersedes (deep_dd, token_risk, ai_contract_risk), so an agent must still infer the boundary itself.

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

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

It implies usage ('One call, agent-ready intelligence') and states the required input and price, but gives no explicit when-to-use/when-not guidance versus the many adjacent token-risk and DD tools in the sibling list. Selection between this and deep_dd/token_risk 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 already establish the safe-read profile, but the description goes well beyond them: it discloses the 6K char cap, length-tiered pricing, the 402 challenge behavior, the x-credit-token prepaid header, absence of a free tier, and — critically — that the output is bare translation with no wrapper prose, safe to pipe. That is exactly the behavioral context an agent needs before paying for a 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?

The core purpose and constraints are front-loaded, which is good, but the text is padded with repetition: pricing is stated twice ($0.03 per call and the length tiers) and 'No API key' appears in both the opening and closing sentences. The redundancy dilutes an otherwise well-structured block.

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 translation primitive with an output schema, this covers everything an agent needs: required input, size limit, target-language field, cost model, payment/auth mechanics, and output shape. Nothing material is left unspecified.

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 a meaningful constraint not present in the schema: the 6K character limit on text and the 'any language' acceptance for to. It confirms text as the required input, slightly exceeding the schema's terse 'Text to translate'.

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 ('Translate ... text ... to any language') with a clear scope limit ('up to 6K chars'). It is easily distinguished from siblings like ai_summarize and ai_extract, and the 'pay-per-call primitive' framing makes the operation type unambiguous.

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

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

Gives explicit contexts — 'localizing content, parsing foreign-language sources, or serving multilingual users' — so an agent knows when this tool applies. It does not name sibling alternatives (e.g. ai_summarize) or state when NOT to use it, so it falls short of a 5.

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

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

Annotations already cover readOnly, idempotent, non-destructive, openWorld, so the safety profile is done. The description adds genuinely new operational context: $0.04 per call over x402 on Base, a prepaid x-credit-token header for unlimited calls, no free tier, and no API key required. That pricing/auth disclosure is exactly the value-add expected when annotations are present.

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

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

Front-loaded with the core purpose, then output contents, then payment terms. Em-dash-heavy but every clause carries information; the only mild redundancy is the explicit 'Required input: hash' which the schema already states.

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

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

An output schema exists so return values needn't be explained, yet the description still previews the response (action, risk read, notes), and it fully covers the payment/auth path an agent needs before calling. Nothing critical is missing, though the lack of sibling disambiguation leaves a small gap.

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

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

With one parameter at 100% schema description coverage, the schema already documents 'hash'. The description only restates 'Required input: hash' without adding format hints (length, 0x prefix, chain specificity). 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 verb and resource ('explains what a Base transaction actually did in plain English') and enumerates the output shape: the action, a risk read, and notes. It implicitly separates itself from raw-decode siblings like tx_decode or base_receipt by emphasizing the plain-English interpretation, but it never names an alternative 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?

The description tells you the required input ('hash') and the payment mechanics, but gives no guidance on when to reach for this versus tx_decode, receipt_parse, or base_tx. Usage is only implied by the 'plain-English' framing, so an agent must infer the boundary itself.

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 the safety profile (readOnly, idempotent, non-destructive, open-world), so the bar is lower. The description adds genuinely useful non-annotation context: priced at $0.06/call over x402 on Base, prepaid x-credit-token header for unlimited calls, no free tier, no API key required.

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 aggregation logic before payment details. Mostly earns its place, though 'flagship wallet report' and 'One call, agent-ready wallet intelligence' are marketing filler that could be trimmed.

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

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

An output schema exists, so return values need no explanation, and payment/auth requirements are fully disclosed. Adequate for a single-parameter tool, with only the verdict's analytical scope left implicit.

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

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

Only one parameter, and schema coverage is 100%, so the schema fully documents 'address'. The description restates 'Required input: address' but adds no syntax, format, or chain-scoping detail. Baseline 3 is appropriate when the schema does the 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?

States a specific synthesis: aggregates net worth, age/activity and recent transactions, then AI produces a verdict (fresh/risky vs established/active). This composite 'AI verdict' framing clearly sets it apart from raw siblings like wallet_networth, wallet_summary or wallet_activity without needing to name them.

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

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

Implies when to use it ('one call, agent-ready wallet intelligence' for a verdict) and states the required input, but never names an alternative for a narrower need (e.g. use wallet_networth for just numbers) or any when-not condition. Usage is inferable but not explicit.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior, so the safety profile is covered. The description adds non-obvious operational context: it is $0.06 per call over x402 on Base, an x-credit-token header buys unlimited calls, there is no free tier, and no API key is required. That payment/auth detail is genuinely useful and 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-loads the value proposition and the produced output before pricing minutiae, and every sentence carries information. The pricing sentence is dense but relevant given no free tier; overall it is appropriately sized.

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

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

An output schema exists, so return values need not be explained, yet the description still summarizes them. Combined with the payment and input requirements, an agent has enough to select and invoke the tool correctly; the only gap is explicit routing against sibling approval/drain tools.

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, so the baseline is 3. The description only restates 'Required input: address' and adds no format, chain, or validation semantics beyond what the schema already says.

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: it pulls a wallet's active token approvals and produces a security audit with risk level, USD at risk, and revoke recommendations. This is much clearer than a name restatement, though it does not explicitly differentiate itself from near-neighbors such as token_approvals, approval_advisor, or wallet_drain_watch.

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 a concrete trigger context — the wallet-safety check run before trusting an address — so an agent knows when it applies. It stops short of naming alternatives or stating when not to use it, so it is not a full 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely new operational context beyond annotations: $0.05 per call over x402 on Base, the prepaid x-credit-token header for unlimited calls, no free tier, and no API key required. It does not disclose rate limits or latency, but the payment/auth disclosure is substantive.

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 and the ranking formula before payment mechanics, which is the right ordering. The opening em-dash fragment ('Which approvals could drain you — and revoke order —') is slightly awkward and the pricing sentence is dense, but overall it is tight and each 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?

An output schema exists, so the description need not explain return values, and it correctly focuses on purpose, the ranking dimensions, the single input and the payment model. For a one-parameter read tool this is complete; only explicit sibling differentiation would push it higher.

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

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

Schema description coverage is 100% and there is a single required parameter ('address'), so the schema already documents the input fully. The description merely repeats 'Required input: address', adding no syntax, format or validation detail beyond the structured field.

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: ranks a wallet's active token approvals by USD-at-risk, unlimited-allowance and unlabelled-spender, and returns a prioritised revoke queue. This is clearly distinguishable from a raw listing or a revoke-transaction builder in principle, but it does not name the sibling tools (token_approvals, revoke_builder) it clearly overlaps with, so the differentiation is only implied.

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 via 'tells an agent exactly what to revoke first', which gives a context for the tool, but there is no explicit when-to-use/when-not guidance and no routing to the closely related approval tools. An agent can infer intent but is not steered away from token_approvals or revoke_builder.

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 the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds material context the annotations do not: $0.03 per call over x402 on Base, a prepaid x-credit-token header for unlimited calls, no free tier on this tool, and no API key required. For an agent deciding whether it can even call the tool, this is high-value disclosure.

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

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

Front-loaded with the core question and the blocklist/allowlist distinction, and the payment terms are placed at the end where they belong. There is mild redundancy — the 'can't receive/hold uninvited' consequence is stated twice — but overall the sentences earn their place.

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

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

An output schema exists, so return values need no explanation, and the description covers purpose, per-scope decoding (send/receive/execute/mint), the sibling boundary, the required input, and the payment/auth model. Nothing an agent needs 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% for the single 'address' parameter, so the schema already documents it. The description only restates 'Required input: address' and adds no syntax, format, or chain detail beyond what the schema provides, making the baseline 3 correct.

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

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

States a precise verb+resource: decodes whether a B20 transfer policy is a BLOCKLIST or ALLOWLIST, per scope. It explicitly names the sibling it is not (b20-safety flags that a policy exists; this decodes its TYPE per scope), so an agent can distinguish the two without opening either schema.

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

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

Draws a clear boundary against b20-safety and explains the practical stake ('the issuer can block bad actors' vs 'a permissioned RWA you can't hold uninvited'), which tells the agent when this matters. It stops short of an explicit use-when/avoid-when rule set, but the sibling routing is clear.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, and the description goes well beyond that with the cost model ($0.03 per call over x402 on Base), the auth path (prepaid x-credit-token header for unlimited calls, no free tier, no API key), and the data origin (CDP-indexed events, active vs ended feed). These are exactly the non-schema behavioral 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?

The read operation is front-loaded and every clause carries information, but there is redundancy — 'issuer notices, corporate actions, redemptions' echoes the opening 'issuer notices & corporate actions' — and the em-dash stacking makes it denser than needed.

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

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

With an output schema present, return values need not be described, and annotations cover the safety profile. What remains — what it reads, from where, what it costs, what auth it needs, and what input it requires — is all stated, so an agent can call this correctly without opening anything else.

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

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

Only one parameter, and schema coverage is 100% ('B20 Asset token address'), so the schema fully documents it. The description's 'Required input: address' merely restates the schema without adding format, constraints, or validation detail.

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

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

States a specific verb and resource — 'Reads a token's announcement feed (active vs ended) from CDP-indexed events' — and defines the underlying primitive (Announcement: id, description, uri) with examples (issuer notices, corporate actions, redemptions). It distinguishes itself from the ERC-20 baseline, though it never names the closest siblings (corporate_actions, rwa_dividend_feed) to differentiate.

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?

Frames itself as 'the issuer-communications primitive for agents holding tokenized/RWA B20 assets', which implies when to reach for it, but there is no explicit when-to-use vs when-not guidance and no named alternative to route against. Adequate context, no routing rules.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real value the annotations don't: the verification mechanism (factory precompile registration + bytecode absence), the anti-spoofing rationale, the enum of possible verdicts, and paid-call behavior ($0.02/call, x-credit-token header for unlimited, no free tier, no API key). That pricing/auth disclosure is exactly the behavioral 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?

Front-loaded with the core question, then rationale, then mechanics, then pricing — a sensible order. Slightly over-written: the anti-scammer justification and the marketing aside ('the 2-cent check') plus a separate pricing sentence restate cost-related points twice, costing a bit of density.

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 needn't be explained, and the description still covers mechanism, verdict enumeration, when to run it, and the x402 payment/auth model. For a one-parameter read tool with a rich annotation set, nothing an agent needs 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% for the single 'address' parameter, so baseline 3 applies. 'Required input: address.' restates the schema's required field without adding format, chain, or validation semantics beyond what is already documented.

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

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

Specific verb + resource: it verifies whether an address is a genuine B20 or a lookalike, and returns a discrete verdict (genuine / fake_lookalike / not_b20). It explicitly distinguishes itself from the rest of the b20_* family by framing itself as the authority check that can't be spoofed, so an agent can route to it without opening schemas.

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

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

Gives explicit ordering guidance ('Run FIRST on any B20') and a reason ('the check that keeps every other B20 answer honest'), which implicitly positions all other b20_* tools as downstream. The agent is told exactly when this tool precedes alternatives rather than being left to infer.

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

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

Annotations already declare readOnlyHint/idempotentHint/non-destructive and openWorld, so the safety profile is covered. The description adds genuinely useful non-annotation behavior: pricing ($0.08/call over x402 on Base), the prepaid x-credit-token header for unlimited calls, no free tier, and no API key requirement.

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 dense with useful contract details. However, the opening redundantly repeats 'up to 5 B20 tokens' twice in the first sentence, wasting space in an otherwise tight definition.

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?

Payment/auth behavior, batch limit, and the scored dimensions are all disclosed, and an output schema exists so return format needn't be explained. Nearly complete for an agent to call it correctly, with only the sibling relationship left implicit.

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

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

Schema description coverage is 100%, so the single 'addresses' parameter is fully documented as comma-separated B20 addresses. The description reinforces it as required and adds the 'up to 5' cap not present in the schema, but adds little else beyond the 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 ('Freeze/seize scan for up to 5 B20 tokens') and enumerates the safety dimensions scored (freeze/seize/pause/rebase/uncapped-mint). It implicitly distinguishes itself from single-token siblings like b20_safety via the explicit 'up to 5' batch scope, but never names the alternative, keeping it 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?

'For portfolio holders and agents screening several B20s at once' gives clear context that selects this tool over the single-token variant. It does not, however, state any exclusions or point explicitly at the single-token alternative for one-off checks.

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

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

Annotations already establish the safe read-only profile, but the description adds genuinely useful non-structural context: per-call price ($0.05 over x402 on Base), the prepaid x-credit-token header for unlimited calls, no free tier, and no API key required. It also explains what counts as failure (the 'transfers brick' scenario). This is exactly the operational detail 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?

Front-loaded with the core purpose and failure modes before cost/auth details, and most sentences earn their place. The opening fragment list and some emphatic phrasing ('transfers brick') are stylistic rather than strictly necessary, costing a small amount of signal-to-noise.

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

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

An output schema exists, so return values need not be re-explained, yet the description goes further by summarizing the verdict taxonomy and the can-this-token-move flag. Combined with cost, auth, input, and audience coverage, an agent has everything needed to call and interpret it correctly.

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

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

Schema coverage is 100% for the single 'address' parameter, so the schema documents the input fully. The description's 'Required input: address' merely restates this and adds no format or interpretation detail (e.g., chain qualifier). Baseline 3 for high-coverage schema 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?

Strong verb+resource: an 'audit'/'misconfiguration lint' of B20 policy scope config, with the specific failure modes enumerated (dangling bindings, ALWAYS_BLOCK, renounced lists, live pauses). It is distinguishable from general siblings like b20_safety or b20_freeze_check by scope, though it never names a sibling it is 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?

Gives clear usage context — 'pre-launch lint for issuers, stuck-funds guard for holders and merchants' — which tells the agent when this tool is appropriate. It stops short of naming alternatives or stating when-not to use it (e.g., versus b20_transfer_preflight or b20_freeze_check).

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

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

Annotations already declare readOnly/idempotent/openWorld, so the bar is lower, yet the description adds substantial context: data source (onchain role events), the exact roles read (mint/burn/seize-via-burnBlocked/pause/admin), what is reported (controllers, centralization, admin renounced), and pricing/auth terms ($0.05/call over x402, prepaid x-credit-token header for unlimited calls, no free tier, no API key).

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 question ('WHO can mint, seize, freeze or pause this B20?') then handles contrast, method, use case, and payment terms. Dense but every clause carries information; the pricing block is slightly heavy but material for callers.

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

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

An output schema exists, so return values need not be described, and the description still covers the data source, the roles inspected, the reported outputs, the use case, and payment/auth mechanics. 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% with a single self-documenting 'address' field. The description only restates 'Required input: address' without adding format, chain, or validation detail beyond the schema. Baseline 3 applies when the schema does the 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?

States a specific verb+resource (reads role-based access control / controllers of a B20 token) and explicitly contrasts with the sibling b20_safety: 'b20-safety tells you WHICH powers a B20 has; this tells you WHO holds them.' An agent can distinguish the two without opening either schema.

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

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

Provides a clear context for use ('The issuer-control map an agent needs before holding a regulated Base-native asset') and implicitly routes the WHICH-powers question to b20_safety. No explicit when-not condition, but the alternative is named and the standing use case is concrete.

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 read-only, idempotent, open-world safety. The description adds critical non-annotation behavior: x402 pricing ($0.75 per call), prepaid x-credit-token header for unlimited calls, no free tier, no API key required, and the specific verdict components returned (issuer-control score, seizure risk, red flags, hold/avoid recommendation).

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 composed dimensions, and payment details are useful. Some marketing phrasing ('premium tier', 'no ERC-20 tool can produce it') is mildly expendable but not harmful.

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, yet the description still outlines the verdict. It covers payment, input, and output adequately, though it does not clarify how it relates to narrower B20 sibling tools, which would help given the crowded suite.

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

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

Schema coverage is 100% and the single parameter is fully documented. The description merely repeats 'Required input: address', adding no format, validation, or usage 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 a specific verb (composes an institutional report/verdict) and resource (Base-native B20 token), and distinguishes from ERC-20 tools. However, it does not name any specific B20 sibling it aggregates, leaving sibling differentiation 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?

Implies an institutional due-diligence context and notes it is premium tier with no free tier, but offers no explicit when-to-use vs alternatives or exclusions relative to the many sibling B20 tools.

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

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

Beyond the read-only/idempotent annotations, it discloses the cost model ($0.03 per call over x402 on Base), the auth mechanism (prepaid x-credit-token header, no API key, no free tier), and the consequence semantics of a negative result (wallet can't transfer and can be burned/seized by the issuer). This is exactly the kind of auth, pricing, and outcome 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?

The core purpose is front-loaded in the first sentence, but the description is padded with marketing-style emphasis ('Is YOUR wallet...', '(SEIZED)') and the 'Required inputs: token, wallet' line duplicates the schema's required list. The pricing and auth lines do earn their place; the redundant input restatement does not.

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

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

For a two-parameter read-only check with an output schema and full annotation coverage, the description supplies everything else an agent needs: what is checked, what a negative result implies, cost, and auth path. Return-value explanation 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% and both parameters are already documented ('B20 token address', 'Your wallet address'), so the schema carries the load. The description only restates 'Required inputs: token, wallet' with no added format, casing, or chain-qualification 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 and resource: checks whether a given wallet is authorized under a B20 token's transfer-sender policy, plus the consequence (can't transfer, can be burnBlocked/seized). It differentiates from b20_safety by framing itself as the per-wallet 'my funds' companion, but does not distinguish itself from other close siblings like b20_gate, b20_transfer_preflight, or b20_policy_members.

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 via the framing question 'can this token freeze MY funds?' and positions itself as the personal companion to b20-safety, implying the per-wallet counterpart to a token-level tool. No explicit when-not-to-use or named alternatives beyond b20-safety, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds material context beyond them: pricing ($0.10 per call over x402 on Base), the prepaid x-credit-token header for unlimited calls, no free tier, and no API key required — all actionable for an agent deciding whether it can 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?

The verdict-oriented purpose is front-loaded and every clause carries information (what it aggregates, the wallet flag, pricing/auth). It is dense and slightly run-on with parentheticals, but not 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?

With an output schema present the description needn't explain the return payload, and annotations cover the safety profile; the description fills the remaining gaps (cost, payment header, required input). It is complete enough to call correctly, though sibling routing remains 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 coverage is 100%, so both parameters are already documented in the schema. The description's 'Pass wallet= to also check if YOUR address is already blocked' and 'Required input: address' essentially restate the schema descriptions rather than adding syntax, format, or edge-case meaning. 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: it produces a single GO/HOLD/STOP verdict for a Base-native B20 token, aggregating seize/freeze/rebase/pause/uncapped-mint checks. It also asserts a routing role ('The B20 tool to bind first'). It does not, however, distinguish itself from the many close siblings such as b20_guard, b20_safety, or b20_transfer_preflight, so the differentiation is asserted rather than demonstrated.

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?

Clear context for use: run it before touching/trading a B20 token, and pass wallet= to additionally check your own address's blocked status. It gives the condition that selects it (pre-trade on a B20) but never names an alternative tool or an exclusion, leaving the agent to guess against b20_guard/b20_safety.

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 the safety profile (readOnly, idempotent, non-destructive), and the description adds substantial context beyond that: the payment model ($0.04 per call via x402 on Base), the x-credit-token prepaid header for unlimited calls, the explicit no-free-tier constraint, and the fact that no API key is needed. It also clarifies the semantic meaning of the bypass window and the verdict outcomes, which 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?

The core purpose and the bypass-window framing are front-loaded, and the reconstructed artifacts plus verdict list are dense but informative. It is slightly run-on with em-dash chains, and the pricing/auth sentence is appended rather than integrated, but no sentence 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?

An output schema exists, so return-value exposition is not required, and the description still enriches it by naming the verdict enum values. Annotations cover safety and the description covers cost and auth, leaving little an agent needs before calling. Only the absence of explicit sibling routing keeps it from a 5.

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

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

Schema description coverage is 100% and there is a single required parameter, so the schema already defines 'address' as a B20 token address. The description only restates 'Required input: address' without adding format, validation, or edge-case meaning. 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 verb (reconstruct/audit) and a precisely scoped resource: what the issuer did inside the initCalls bypass window, enumerating the artifacts recovered (pre-mints, role grants, policy bindings, blocklist seeding) and the verdict taxonomy. This is unmistakably distinct from near-siblings like b20_config_audit, b20_launch_radar, or b20_dossier 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 frames the scenario well (the one-tx privileged window only the issuer gets) and names the required input, so the agent can infer when it applies. However, it never explicitly states when to prefer this over b20_config_audit, b20_control, or b20_dossier, nor any exclusion criteria, so the routing decision 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 already cover the read-only/idempotent/open-world profile, but the description adds substantial context beyond them: the sub-second webhook capture model, pricing ($0.05/call over x402 on Base), auth via prepaid x-credit-token header, no free tier, and no API key required. This is exactly the operational disclosure 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?

Purpose is front-loaded and the dual-mode usage and pricing each earn their place. The em-dash-heavy run-on construction is dense but not 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?

Covers mode selection, real-time behavior, pricing and auth; an output schema exists so return values need no explanation, and annotations carry the safety profile. 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?

With a single optional parameter at 100% schema coverage, the schema already documents the address. The description reinforces its meaning (address = live guard status; omission = network feed), adding modest behavioral clarity but little 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+resource: real-time alerts when a B20 token turns seizable, explicitly positioning itself as 'the live layer over B20 Policy Watch.' An agent can distinguish it from b20_policy_watch, b20_freeze_check and b20_seizure_history without opening 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?

Gives clear dual-mode routing: pass an address for live guard status, omit it for the network-wide feed of newly-seizable tokens. It names the sibling it layers over (B20 Policy Watch) but doesn't state when to prefer this vs. b20_freeze_check or b20_seizure_history, so exclusions are incomplete.

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 the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description is not repeating them. It adds genuinely useful non-schema behavior: provenance of the data (the precompile), a concrete price ($0.02/call over x402), the x-credit-token header alternative for unlimited calls, and the explicit note that no API key is required and no free tier exists.

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

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

Three sentences, front-loaded with the payload description followed by sourcing, input, and payment mechanics. There is mild redundancy between 'Full profile of a Base-native B20 token' and 'Complete B20 token profile' in the same sentence, but no padding beyond that.

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

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

With an output schema present, the description needn't explain return values, and it covers the remaining essentials: what class of data, the authoritative source, the required input, and the payment/credit model. The one gap is the lack of any routing against closely overlapping B20 siblings, which matters given how many exist.

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

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

Only one parameter and schema description coverage is 100%, so the schema already fully documents 'address'. The description's 'Required input: address' restates the schema's required array without adding format, chain, or validation meaning, which is the expected baseline-3 outcome 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?

Names a specific verb+resource (full profile of a Base-native B20 token) and enumerates exactly which fields are returned (variant, name, symbol, decimals, supply, cap, policies, pause states, rebase) plus the data source ('straight from the precompile'). It partially differentiates from b20-safety as the 'data companion', but does not distinguish itself from overlapping siblings like b20_metadata, b20_dossier, b20_supply, or b20_rebase.

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?

Signals an implied usage context by calling itself the 'data companion to b20-safety', suggesting a read-the-data role versus a risk-assessment role. However, there is no explicit when-to-use guidance and no routing statement telling the agent when to prefer b20_metadata, b20_dossier, or b20_supply instead.

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 the safety profile (readOnly, idempotent, non-destructive, open-world), and the description adds substantial beyond it: the x402 pricing model ($0.01 per call), the prepaid x-credit-token header for unlimited calls, the absence of a free tier, and that no API key is required. The 'new ≠ safe' warning and the b20-safety routing are real behavioral context 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 core purpose before details, and the pricing/header clauses are separated from the functional description. It is dense with em-dashes and slightly marketing-flavored, but every sentence (fields, discovery framing, safety warning, pricing) 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?

Output schema exists, so return values need not be explained, and the description still names the key fields. Pricing, auth model, and safety follow-up are all disclosed. The only gap is the vague semantics of the `limit` parameter, which neither schema nor description clarifies.

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 (limit) with 100% schema coverage, though its schema text ('How many') is terse. The description adds no meaning to the limit parameter, so the baseline of 3 applies when the schema carries the load.

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

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

Specific verb+resource: lists the newest B20 tokens on Base from the B20Factory precompile, and even names the returned fields (variant, symbol, decimals, block). It scopes itself to B20 tokens, implicitly narrowing against generic siblings like new_tokens/trending_tokens, but never explicitly contrasts with them, so it falls short of full sibling differentiation.

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?

Frames itself as 'a discovery feed for agents hunting new B20 launches early' and gives a concrete follow-up instruction ('Run b20-safety on any address before touching it — new ≠ safe'). It does not state when to prefer this over new_tokens or trending_tokens, so there is context but no explicit alternatives 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 already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), but the description adds genuinely new behavioral context: x402 pricing at $0.03/call, the prepaid x-credit-token header for unlimited calls, absence of a free tier, and no API key requirement. It omits any note on result volume/pagination, which keeps it below a 5.

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

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

Front-loads the token/purpose before the operational details (filters, required input, pricing), and the pricing/required-input sentences earn their place. The opening clause is somewhat promotional and the single dense paragraph could be trimmed, but there is little outright waste.

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

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

With a full output schema and complete annotations, the description only needs to orient the agent, and it covers purpose, filterable dimensions, required input, cost model, and auth. Nothing critical is missing; only edge-case behavior (pagination, empty results) 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 the schema already documents address, memo, and caller. The description restates that reads can be 'optionally filtered by a specific memo (bytes32) or the caller wallet' but adds no semantics beyond the schema (e.g. matching behavior, case sensitivity, empty-memo handling), so baseline 3 applies.

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

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

Names a specific verb and resource ('Reads a token's on-chain Memo event history') and scopes it with the filterable dimensions (memo bytes32, caller wallet). It also distinguishes the B20 primitive from ERC-20 and from sibling B20 tools like b20_seizure_history or b20_transfer_preflight by framing memos as the settlement-reconciliation record.

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 this applies: 'The settlement-reconciliation primitive for agents paying over B20 stablecoins', plus the required input. It does not name an alternative sibling or state when NOT to use it (e.g. vs. a generic transfer lookup), so it stops short of explicit 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?

Far exceeds annotations by disclosing payment mechanics ($0.04 per call over x402 on Base, prepaid x-credit-token header for unlimited calls, no free tier, no API key), the METADATA_ROLE capability (updateName/updateSymbol), and exactly what on-chain history it inspects. Annotations only cover read-only/idempotent/open-world safety.

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 key question and answer, then flows into mechanics, guidance, and pricing. It is fairly long, but most sentences carry distinct information; only the explanatory aside about ERC-20 having no equivalent is slightly 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?

Complete for a read-only, single-address tool with an output schema. The description states what is checked (mutability and rename history), the required input, and the payment/auth model, so an agent has enough to invoke it correctly.

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

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

Schema coverage is 100% and the only parameter is already documented as 'B20 token address'; the description's 'Required input: address' adds no syntax, format, or validation detail beyond the schema. Baseline 3 applies when the schema does the parameter documentation.

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 read operation on B20 token metadata: mutability via METADATA_ROLE and rename history via NameUpdated/SymbolUpdated. The opening questions make the purpose concrete, but it never names or contrasts with sibling tools such as b20_authenticity or b20_info, so sibling differentiation is missing.

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

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

Provides clear context for engagement—checking whether a B20 token can or has renamed itself to detect impersonation/bait-and-switch—and advises 'Trust the address, not the label.' However, it does not give explicit when-not conditions or route the agent to alternative tools.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely non-structural facts: pricing at $0.03/call over x402 on Base, the prepaid x-credit-token header for unlimited calls, no free tier, and no API key required. It also discloses the output classification labels (heavy_dilution / active_minting / minor_minting / quiet), though it says nothing about window alignment or error behavior for unsupported addresses.

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 value proposition and the sibling differentiation are front-loaded, and the payment mechanics come after. It is dense and slightly stream-of-consciousness with em-dashes and a marketing hook, but almost every clause carries actionable 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 two-parameter read tool with an output schema, the description covers purpose, alternative, parameter range, payment/access model, and the classification vocabulary. Only edge-case behavior (invalid token, empty window) is unaddressed, which is a minor gap given the output schema carries return structure.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds a constraint the schema lacks entirely: the valid range for days (1-90) alongside the default of 30. It adds little on address beyond 'Required input', which the schema's required array already conveys.

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 ('every mint incl. batchMint in the window: amount, recipients, share of current supply') and explicitly contrasts itself with the sibling b20_supply ('shows the dilution ceiling; this shows the actual printing'). An agent can distinguish the two without opening either schema.

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

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

Names one explicit alternative (b20_supply) and the condition that selects it, plus the intended audience ('agents holding B20 stablecoins and RWAs'). It does not state when not to use it or mention other adjacent siblings like b20_rebase_history or token_transfers, so it stops short of full routing guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds real operational context: it discloses the discrete result states (on_peg / depeg_warning / depegged / no_market / unverifiable_fx) and the payment model ($0.03 per call over x402 on Base, prepaid x-credit-token for unlimited use, no free tier, no API key). The cost/auth disclosure is genuinely useful 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?

The core concept (declared peg vs market price) is front-loaded, and the outcome states and payment model follow logically. It is em-dash-heavy and slightly dense, but nearly every sentence carries information an agent needs; minimal waste.

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, output-schema-backed read check, the description supplies everything needed: the concept, the trigger condition, the result taxonomy, and the cost/auth model. With an output schema present it correctly avoids restating return values in detail.

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

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

Schema coverage is 100% for the single parameter, so the schema already documents 'address.' The description merely restates the requirement ('Required input: address') without adding format, chain, or validation meaning beyond the schema. Baseline 3 is correct.

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

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

Names a specific verb+resource (compare a B20 stablecoin's self-declared currency() against actual DEX market price) and frames it against the sibling verification tools by noting 'the standard verifies nothing' and calling it 'the missing check.' An agent can distinguish it from b20_stablecoin, b20_authenticity, or stablecoin_peg without opening 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?

Gives a clear trigger — 'Run before settling in any B20 stablecoin' — which tells the agent exactly when this belongs in a workflow. It does not explicitly name an alternative sibling or a when-not condition, so it stops short of full routing guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive, yet the description adds substantial context they don't carry: x402 pricing on Base ($0.03/call), the prepaid x-credit-token header for unlimited calls, no free tier, no API key required, and the anti-replay rationale for fetching the nonce. That is exactly the beyond-annotations value this dimension rewards.

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 outputs are front-loaded, and every clause is relevant, but it is a dense em-dash run-on that mixes purpose, output list, pricing, and auth into one paragraph. It would read better as two or three sentences, costing 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?

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. The description closes the remaining gaps an agent would care about – cost, payment/auth mechanism, and what is and isn't signed – leaving nothing material unstated.

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

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

Schema description coverage is 100% and both params are documented there, so the baseline is 3. The description reinforces 'required input: address' and explains the nonce/replay purpose of the owner param, but adds no syntax or format detail the schema doesn't already supply.

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 ('reads DOMAIN_SEPARATOR, owner nonce, EIP-712 domain/type struct') rather than restating the name. An agent can immediately tell this inspects ERC-2612 permit prerequisites, not generic B20 metadata, so it is distinguishable from the many b20_* siblings 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?

It gives clear context for when to reach for it: when an agent needs to build a valid permit signature, and it explicitly notes 'signs nothing' and read-only behavior. It stops short of naming an alternative or a when-not condition, but the usage 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 already declare readOnly, idempotent, openWorld and non-destructive. The description adds genuinely non-obvious operational context: p pricing at $0.04/call over x402 on Base, a prepaid x-credit-token header for unlimited calls, no free tier, and no API key required. It adds no detail about the response shape, but that is covered by the output schema.

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

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

Every sentence carries information (purpose, sibling differentiation, pricing), but the leading rhetorical question ('WHO administers the blocklist that can freeze you?') and the repeated 'other half of who can freeze/seize you' framing are stylistic padding for a one-parameter read tool. Front-loading is good, but the phrasing is heavier than needed.

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

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

With an output schema present, return values need not be described, and the annotations cover the safety profile. The description supplies purpose, sibling routing, input requirement, and pricing/auth mechanics, so an agent has what it needs; only the near-sibling differentiation among b20_policy_watch/policy_members is thin.

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% for the single 'address' parameter, so the schema already carries the semantics. The description only restates 'Required input: address' and does not add format or source hints (e.g. that it should be the B20 token address) beyond what the schema provides. Baseline 3 applies.

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

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

States a specific verb+resource: it reads who administers each active transfer/mint policy (policyAdmin), pending handover (pendingPolicyAdmin), and renouncement status, straight from the Policy Registry. It explicitly distinguishes itself from b20-control ('reads the token's own roles') and from the registry-based control angle, so an agent can tell it apart from the many b20_* siblings.

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

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

Gives clear context: this is the complement to b20_control for the 'who can freeze/seize you' question, and it must be sourced from the Policy Registry rather than the token itself. It doesn't explicitly rule out or route away from near-neighbors like b20_policy_members or b20_policy_watch, so it stops short of full when/when-not guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the bar is lower. The description adds genuinely useful behavior the annotations do not: provenance (events replayed from the Policy Registry), historical attribution ('when, by whom'), and cost/auth model ($0.05 per call via x402 on Base, x-credit-token for unlimited calls, no API key, no free tier). Mostly strong, though the 'compliance-grade visibility no other tool provides' line is promotional rather than behavioral.

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

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

The key differentiator is front-loaded and the structure is logical. However, it is dense and includes filler ('Compliance-grade visibility no other tool provides'), and the pricing/auth detail trails at the end rather than being tighter.

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

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

An output schema exists, so return values need no explanation. The description covers purpose, the competing sibling, both parameter options, and the payment/auth model — everything an agent needs to invoke it correctly for a read-only, two-optional-param 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%, so the baseline is 3, but the schema descriptions are bare ('Registry policy ID (optional)', 'B20 token address') and omit the relationship between the two. The description clarifies that either address= or policy= selects the same resource, which is real added meaning.

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

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

The description states a specific verb+resource: replaying BlocklistUpdated/AllowlistUpdated events to enumerate the full membership of a B20's blocklist/allowlist, including attribution and current member set. It explicitly contrasts itself with b20_freeze_check ('answers one wallet; this enumerates the WHOLE list'), so an agent can disambiguate without opening 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?

It names the alternative tool and the condition that selects it: use b20_freeze_check for a single wallet, use this for the whole list. It also states which parameter form to pass (address= for a token, policy= for a registry policy ID). Routing is fully explicit.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds real context beyond them: the pricing model ($0.03/call over x402 on Base), the prepaid x-credit-token header for unlimited calls, the absence of a free tier, and no API key requirement. These are operationally decisive details 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?

The core question is front-loaded and the structure is logical (what it does, the vector, the inputs, the pricing). It is somewhat dense and marketing-flavored with em-dash asides, but each sentence carries information rather than 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 format needn't be explained, and rich annotations carry the safety profile. The description also covers payment and access requirements. It is close to fully self-sufficient; 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?

There is a single required parameter with 100% schema coverage; the schema already documents 'address' as the B20 token address, and the description only restates 'Required input: address.' No format or syntax is added, so the baseline 3 applies.

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

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

States a specific verb and resource ('reads the token's full policy/pause event timeline plus the live policy state') and a distinct outcome ('tells you if — and exactly WHEN — it turned seizable'). This is clearly separable from siblings like b20_freeze_check, b20_seizure_history, and b20_policy_admin 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?

Gives a clear scenario framing: 'Did this token BECOME seizable after launch?' and names the threat model it addresses (the B20-only rug vector). However, it does not explicitly state when to prefer this over b20_seizure_history or b20_freeze_check, leaving sibling 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety bar is lower. The description adds real behavioral context beyond that: the x402 $0.06 per-call pricing, the prepaid x-credit-token header for unlimited calls, the explicit absence of a free tier, and no API key requirement — all material to an agent deciding whether it can afford to 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-loads the core question and capability, then covers return shape, input, and pricing in a compact flow. Slightly dense with pricing/header mechanics, but every clause is informative for an agent, 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?

An output schema exists, so return-value explanation is not required, yet the description still summarizes the return shape (per-token flags plus wallet-level verdict). Combined with the pricing/auth details, an agent has enough to invoke correctly; only sibling disambiguation is thin.

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% for the single wallet parameter, so the schema already carries the semantics. The description only restates "Required input: wallet" and adds no format, validation, or address-type nuance beyond what the schema provides.

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

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

States a specific verb and resource ("Scans a wallet's B20 holdings for protocol-level freeze/seize powers") plus the distinctive scope of checking whether the caller's own address is already blocked. It differentiates from generic ERC-20 portfolio tools, but does not name the closest B20 siblings (b20_freeze_check, b20_guard, b20_safety), so an agent cannot fully disambiguate from those.

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 framing ("Built for agents holding Base positions") implies the audience and the risk-check use case, but no explicit when-to-use/when-not or named alternatives are given. The agent must infer that this is the portfolio-level B20 risk scan rather than the single-token freeze check.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds genuinely non-structured context: the x402 payment model on Base, the $0.02 per-call price, the prepaid x-credit-token header for unlimited calls, the absence of a free tier, and no API key requirement — all auth/cost details the 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 is front-loaded in the first clause and the description is dense rather than padded. The em-dash fragments and payment boilerplate add length, but every sentence carries information relevant to calling the tool.

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

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

An output schema exists, so return-shape explanation is unnecessary, and the description still supplies payment/auth requirements, the balance-scaling interpretation, and the stablecoin edge case. The main omission is sibling routing, which would be needed for an agent choosing among the many b20_* tools.

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, fully described in the schema ('B20 token address') at 100% coverage, so the schema does the work. The description restates that address is required but adds no format, checksum, or chain details beyond what the schema already provides.

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

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

States a specific verb and resource: reads a B20 Asset token's rebase multiplier, with a clear secondary purpose of flagging whether holder balances are being scaled. It partially differentiates from siblings by noting stablecoin variants return no-rebase, though it never names the closest sibling (b20_rebase_history) that an agent might confuse it with.

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 (checking whether an issuer is scaling balances through rebase) but there is no explicit when-to-use or when-not-to-use guidance, and no routing to b20_rebase_history, b20_supply, or b20_stablecoin. The stablecoin aside hints at scope boundaries but is framed as a return-value fact rather than a selection rule.

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

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

Annotations already declare this a safe idempotent read, so the bar is lower, yet the description adds real non-obvious context: a per-call price ($0.03 over x402 on Base), the prepaid x-credit-token header for unlimited calls, no free tier, and no API key requirement. These auth/cost details are exactly what annotations cannot express, though return shape and pagination are left to the output schema.

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

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

The purpose and the b20_rebase contrast are front-loaded, and the pricing/auth sentences earn their place. However, the rhetorical triple 'no transfer, no per-account event, nothing in your tx history' and the em-dash-heavy cadence add length without adding information, diluting a fairly dense 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 values need not be explained, and the description still covers purpose, the sibling alternative, the downward-move flagging behavior, and the payment/auth model. It is complete enough to invoke correctly; only the exact output fields/history depth are left to the 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 coverage is 100% and the sole parameter is documented in the schema as the B20 Asset token address. The description only restates 'Required input: address' without adding format, network, or validation meaning, so the baseline 3 is correct.

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

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

States a specific verb (replays the full MultiplierUpdated history) and resource (a B20 asset's multiplier rescaling), and explicitly distinguishes itself from the sibling b20_rebase ('shows today's value; this replays the full history and flags DOWNWARD moves'). An agent can select between the two without opening either schema.

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

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

Names the alternative (b20_rebase) and the condition that selects it (current value vs. full history of downward moves), plus a use context ('before you hold a rebasing RWA'). It stops short of explicit when-not-use or failure-condition guidance, so it falls just below the top band.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description goes beyond them with real operational context: $0.04 per call over x402, an x-credit-token header for unlimited calls, no free tier, and no API key. It also discloses what it actually inspects on chain (transfer-policy admin), which the annotations do not cover.

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

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

The core question is front-loaded, which is good, but the body is padded with promotional copy ('— Live —', 'all 13 Coinbase equities, and the next on day one') and crowded pricing/header sentences that could be trimmed. Several clauses serve marketing rather than agent decision-making.

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 annotations cover safety semantics. The description still supplies the missing pieces an agent needs – what powers are read, the verdict scale, cost, and auth – making it nearly complete for a single-parameter read 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 'address' parameter is documented in-schema, so the baseline is 3. The description only restates that 'address' is required and adds no format, chain, or validation nuance beyond the schema.

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

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

The description states a specific verb+resource: it reads a B20 token's protocol-level freeze/seize/mint powers (Policy Registry, burnBlocked) into a single hold/caution/avoid verdict, and clarifies scope by distinguishing a genuine tokenized stock from an equity-ticker impostor. It never names the many nearby siblings (b20_freeze_check, b20_control, b20_guard, token_risk), so differentiation is left implicit.

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 framing (assess whether a B20 token can freeze/seize funds) and the required 'address' input is stated, but there is no explicit when-to-use/when-not guidance and no routing to alternatives despite seven-plus overlapping b20_* and risk siblings. An agent must infer the trigger condition.

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 the safety profile (readOnly, idempotent, non-destructive), and the description goes further with cost and auth mechanics: $0.05 per call over x402 on Base, prepaid x-credit-token header for unlimited calls, no free tier, no API key required. It also explains what the verdict values mean (enforced / armed / no_seize_power), which is real behavioral context an agent needs before calling.

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?

Strongly front-loaded — a question hook, then the CAN/HAVE-DONE contrast, then the verdict semantics, then parameter usage and pricing. It is slightly dense and the pricing sentence packs several facts, but every sentence carries information an agent needs.

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

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

An output schema exists so return-format detail isn't needed. Combined with annotations covering safety and the description covering purpose, parameter usage, verdict semantics, and payment/auth requirements, 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 description coverage is 100%, so the schema already documents both parameters ('Victim wallet (optional)', 'B20 token (omit for network feed)'). The description's guidance on wallet= vs address= and omission largely restates that, giving only marginal added meaning. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource — scanning a B20 token's actual BurnedBlocked seizure events — and explicitly positions itself against the rest of the B20 family ('Every other B20 check reads what the issuer CAN do; this reads what they HAVE done'). An agent can identify it apart from siblings like b20_freeze_check or b20_control 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?

It gives explicit usage modes ('Pass wallet= for one address, or omit address= for the network-wide feed') and a clear differentiator against alternatives in the same family (CAN vs HAVE DONE). Both the when-to-use and the sibling distinction are stated rather than implied.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real behavioral context on top: the currency code is the issuer's claim, not attested backing; pricing is $0.03 per call over x402 on Base; a prepaid x-credit-token header unlocks unlimited calls; there is no free tier and no API key. These auth/payment and trust caveats are exactly the disclosure that helps an agent invoke correctly.

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 in the opening clause, and the sentences largely earn their place (the caveat and pricing details are actionable). The single em-dash-heavy paragraph is dense but not 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The description still covers the trust caveat, payment/auth requirements, and the required input, leaving nothing essential for a correct call 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% for the single address parameter, so the schema already documents it fully. The description only restates 'Required input: address' and adds no syntax or format detail beyond the schema, making the 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 and resource: reads the declared peg currency alongside issuance (supply, cap) and control powers (seize/freeze/pause/uncapped-mint), summarized as a one-call 'what is this stablecoin and who controls it'. The composite scope is clear, but it does not explicitly distinguish itself from close siblings like b20_peg, b20_supply, or b20_control, so an agent must infer the difference.

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?

Offers a usage context ('for agents settling in B20 stablecoins') but no explicit when-to-use-vs-alternatives guidance. It never says when to prefer this composite call over the narrower b20_peg / b20_supply / b20_control siblings, leaving 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?

Annotations already declare read-only, idempotent, non-destructive, and open-world behavior. The description adds context beyond those fields: it explains what is read (supply cap vs minted supply and on-chain SupplyCapUpdated history), how uncapped mint is interpreted, and the x402 payment model including prepaid header and lack of a free tier.

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

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

The description is front-loaded and generally dense with useful information. However, some sentences are redundant with structured fields, such as 'Required input: address,' which the schema already announces, making it slightly less tight than it could be.

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

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

Given the tool's read-only nature, single required parameter, existing output schema, and rich annotations, the description is complete enough for an agent to select and invoke it correctly. It covers purpose, sibling relationships, risk interpretation, and payment requirements.

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 one required parameter and schema coverage is 100%, so the schema already documents that 'address' is a B20 token address. The description only says 'Required input: address,' adding no meaning beyond the structured schema. This matches the baseline for high schema coverage.

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 resource and action: mint headroom and dilution history for a B20. It explicitly distinguishes itself from sibling tools by noting that b20-safety covers seizure and b20-control covers the mint role, so an agent can route correctly without opening schemas.

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

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

It names the complementary sibling b20-safety, clarifies that this tool covers only the dilution half of rug risk, and recommends pairing with b20-control to see who holds the mint role. This supplies explicit when-to-use guidance and alternatives.

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 the safety profile (readOnly, idempotent, non-destructive), and the description adds what they cannot: the $0.04 per-call x402 price on Base, the prepaid x-credit-token header for unlimited calls, 'no free tier on this tool,' and 'No API key required.' It also explains the internal check composition (sender/receiver/executor policy resolution plus live transfer-pause), which is genuine behavioral disclosure.

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

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

Front-loaded with the decision question and the GO/HOLD/STOP output, and the pricing/auth sentence is dense and useful. Minor waste remains: 'Required inputs: address, from, to' restates the schema's required array, and a couple of clauses ('bought once') are rhetorical rather than informative.

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, annotations covering safety, and 100% schema description coverage, the remaining burdens are purpose, routing, and payment/auth mechanics — all addressed. Nothing an agent needs to decide whether and how to call this per-payment preflight 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 goes further by explaining what each address means operationally — sender policy is resolved against 'from', receiver policy against 'to', executor policy against the optional operator. That interpretive layer is not present in the schema descriptions, though it stops short of format/syntax detail for the addresses.

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

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

The opening question names the exact verb and resource: 'Will THIS transfer (from→to) clear right now?' and immediately scopes it as 'the per-transaction B20 rail check' returning GO/HOLD/STOP. It explicitly contrasts itself with the rest of the B20 family ('every other B20 tool is per-token due diligence'), so an agent can separate it from b20_safety, b20_gate, etc. without opening 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?

States both the trigger ('the check an agent runs on every payment') and the non-use case (other B20 tools are one-time per-token diligence), plus an exclusion against a whole tool class ('No ERC-20 tool can see it'). This is explicit when/when-not guidance rather than an implied context.

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

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

Annotations already declare readOnly/idempotent/non-destructive. The description adds meaningful context: best-effort parsing, a 500-row cap, and the pricing/auth model ($0.01/call over x402, prepaid header, 1 free call/day, no API key). This goes beyond the annotations with operational constraints.

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 transformation ('Messy bank export → one row shape') then packs constraints efficiently. Slightly dense with pricing/billing detail, but each clause carries information an agent or caller needs.

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

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

Covers input formats, supported headers, row limit, best-effort nature, and pricing/auth. Output schema exists so return shape needn't be explained. Complete enough to invoke correctly, though aliases ('TR aliases') are under-explained.

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 (text) with 100% schema coverage, so baseline is 3. The description clarifies that text is CSV content in multiple delimiter formats, adding minor meaning over 'CSV text' but the schema already documents it.

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: parse a bank CSV and map headers into a unified schema. It names the concrete input formats (comma/semicolon/tab, quoted fields) and supported header fields, making the tool's function unambiguous even among many 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?

Implies when to use it (messy bank export normalization) but offers no explicit exclusions or alternatives. Sibling list has no direct CSV-normalize competitor, so differentiation is less critical, but usage context is only implied.

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

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

Beyond the readOnly/idempotent/openWorld annotations, it discloses the pending-block contract ('answers found:false with the reason rather than an error'), that output is raw and uninterpreted, the pricing model ($0.002 per call over x402 on Base), the prepaid x-credit-token auth header, the 1 free call/day allowance, and that no API key is needed. That is a dense, non-obvious behavioral payload the 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.