x402 Bazaar

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the description adds value by explaining the data source (Base RPC), the pricing model, the x402 payment requirement, the prepaid x-credit-token option, and the free daily call. It also states that no wallet or API key is required, which is useful access context beyond the annotations.

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

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

The description is compact and front-loaded: the tool's core output appears first, followed by use cases, then required input, then pricing/access details. Every sentence adds relevant information, and there is no redundant or filler content.

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

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

For a single-parameter read-only tool with rich annotations, the description is nearly complete: it names the output fields, use cases, required input, pricing, and access model. It could more deeply explain what 'activity level' means, but the provided detail is enough for an agent to invoke the tool confidently.

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 only one parameter and a minimal schema description that simply says 'Address', the description compensates by clarifying that the address must be a Base address and that it is required. This adds meaningful network-level specificity beyond the schema.

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

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

The description clearly states the tool provides an instant profile of any Base address, listing specific outputs: EOA vs contract, ETH + USDC balance, transaction count, and activity level. The scope is well-defined, though it does not explicitly distinguish itself from sibling tools such as wallet_summary or counterparty_check.

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

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

The description gives clear context by stating it is useful for counterparty and wallet checks, and notes the required input is an address. It does not name alternative sibling tools or explicitly say when not to use it, but the use case is clear enough for an agent to make a reasonable selection.

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

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

The annotations already mark this as read-only/idempotent/non-destructive, and the description adds substantial behavioral context: it reads an EAS attestation on Base, requires no wallet or API key, costs $0.03 per call with prepaid header or free daily tier, and returns a verdict plus trust score. It also warns that identity is a signal, not proof, which is valuable calibration for the agent.

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

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

The description is longer than average but information-dense and front-loaded with the core purpose before moving to verification details, usage pairing, pricing, and requirements. Every sentence adds operational or contextual value; minor redundancy exists around 'required input: address' given the schema already marks it required, but overall it is well structured.

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

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

The description covers what the tool does, how the verification works, what network it operates on, what it returns at a high level, how to pay for it, auth requirements, and sensible companion tools. With an output schema present, the absence of detailed return field documentation is acceptable. Nothing critical is missing for an agent to decide whether and how to invoke it.

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

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

The schema already documents 'address' as 'Address to check' with 100% coverage, so the baseline applies. The description only restates that address is the required input and adds the contextual framing of 'counterparty,' but it does not provide additional format, network, or validation details beyond what the schema and overall description already imply.

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

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

The description opens with a clear, specific question—'Is this counterparty Coinbase-verified or an anon/sybil?'—and names the exact resource and signal: Coinbase's ONCHAIN EAS attestation plus Basename. It clearly identifies the tool's distinct role as a counterparty identity/trust check, separating it from generic address or risk tools.

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

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

The description gives concrete usage context: it is the 'who am I dealing with?' pre-transaction check and explicitly suggests pairing with sign-guard/spend-audit for a full pre-transaction gate. It also includes a caveat that identity is not proof of honesty, but it does not explicitly name alternatives to avoid using this tool for.

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

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

Annotations already establish read-only, idempotent, open-world, non-destructive behavior. The description adds valuable context beyond annotations: no wallet/API key required, €0.06 pricing model, x402/x-credit-token payment behavior, and free tier. It also clarifies the output includes a revoke queue, which helps set expectations despite the output schema being present.

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

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

The description is front-loaded with the core purpose and includes useful details about pricing, auth, and usage. However, there is noticeable redundancy: the opening phrase, 'complete fund-movement authority', 'one drain-surface verdict', and 'only combined check' all convey similar positioning. A tighter edit would improve clarity without losing meaning.

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

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

For a single-parameter, read-only tool with an output schema present, the description is reasonably complete. It covers the two audit surfaces, the use case, return concept, required input, pricing, and authentication expectations. It does not describe output fields in detail, but that is acceptable because the output schema exists.

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

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

The schema already documents the only parameter `wallet` with 100% coverage. The description adds minimal parameter-specific meaning beyond clarifying the wallet is a Base wallet and that it is required, which is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly defines the tool as a combined audit of ERC-20 approvals and Base Account spend permissions, and states the output as a single drain-surface verdict with a revoke queue. It explicitly contrasts itself with approval-only and spend-permission-only tools, making its unique purpose 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?

The description gives a strong usage cue: use this tool when an agent wallet must know its complete fund-movement exposure before holding funds. It also explains why approval-only and spend-permission-only tools are insufficient. However, it does not explicitly name sibling tools or state when NOT to use this tool in favor of a narrower alternative.

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

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

Annotations already establish read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful operationaal context: it combines secarity flags with the ABI, uses Claude to generate an explanation, returns a danger level, costs $0.04 per call on x402/Base, supports a prepaid x-credit-token header, offers a free tier, and requires no wallet or API key. No contradiction with annotations.

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

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

The purpose is front-loaded and the pricing/auth details are placed at the end, which helps an agent scan quickly. There is a little redundacy in saying both 'what dangerous powers a contract has' and 'explains the contract's dangerous capabilities,' and the required-input line duplicates the schema, but overall the text is dense and mostly worthwhile.

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

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

For a one-parameter, read-only tool with an output schema and strong annotations, this description covers the key call-time facts: purpose, input, source data, output nature, danger level, pricing, authentication mechanism, free tier, and account requirements. 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?

There is only one parameter, address, and the schema already describes it as 'Contract address' (100% schema description coverage). The description merely repeats 'Required input: address' and adds no new detail about format, chain, checksumming, or address type, so the baseline score of 3 applies.

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

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

States a specific verb and ressource: it explains a contract's dangerous capabilities by combining secarity flags with the verified ABI names and outputs a danger level. It also distinguishes itself from raw-flag approaches by claiming it 'goes beyond raw flags,' though it does not explicitly name sibling tools like contract_danger or rug_score.

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

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

Usage context is implied: an agent would call this when it needs a plain-English explanation of what dangerous powers a contract has, rather than raw flags. However, there is no explicit when-to-use, when-not-to-use, or named alternatives among the many risk-related sibling tools, so the agent must infer selection.

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

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

Annotations already mark the tool as read-only and idempotent, and the description adds substantial behavioral context: guaranteed-valid structured outputs, exact-key behavior, list extraction semantics, character limits, pricing model, and authentication requirements (x-credit-token header, no wallet/API key). No contradiction with annotations.

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

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

The description is dense but every sentence earns its place: purpose, parameter usage, list behavior, size limit, sibling routing, pricing, and auth are all relevant for an agent. It is front-loaded with the core value proposition and wastes no words.

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 presence of an output schema, the description does not need to explain return structure. It covers required input, optional parameters, limits, use cases, alternatives, billing, and authentication, making it fully actionable for an agent with no prior context.

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?

While schema coverage is 100%, the description goes far beyond the schema: it explains fields as a comma-separated list up to 10 items, clarifies list=true returns an array of repeated records, and confirms text is required. This adds meaningful invocation details beyond the bare parameter descriptions.

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

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

The description uses a specific verb and resource: converting unstructured text into schema-enforced JSON via extraction. It clearly distinguishes itself from siblings by noting it is 'the universal parse step' and explicitly routes large jobs to ai-extract-batch.

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 specifies when to use this tool ('pages, emails, receipts, logs'), when to add list=true for repeated records, and names the batch alternative for many documents. It also gives concrete constraints like 16K chars and required input text, so an agent can decide to invoke it confidently.

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

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

The description adds substantial behavioral detail beyond the readOnly/idempotent annotations: one schema-enforced JSON object per document returned in order, 6K character limit, single paid call, prepaid credit header, one free call per day, and no wallet/API key requirement. These details give an agent actionable expectations without contradicting annotations.

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

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

The description is dense but every sentence earns its place: core behavior, batching mechanism, output shape, cost model, limits, required input, and authentication are all covered. The most important purpose and differentiator are front-loaded, and no filler is present.

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 batch complexity, the description covers input limits, multi-document formatting, output ordering and schema enforcement, payment model, and access requirements. An output schema exists, so the description does not need to spell out return field details. The agent has everything needed to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents parameters. The description goes further by explaining practical usage: text1=…&text2=…, texts= with ||| separators, one shared field list, and per-document character limits. This adds real value beyond the raw schema.

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

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

The description states a clear verb and resource: batch extraction over multiple documents. It explicitly identifies itself as 'The pipeline version of ai-extract' and contrasts its behavior (up to 10 texts, one field list, one payment) with the sibling tool, making differentiation easy.

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

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

The description gives solid context for when to use the tool: same fields across up to 10 documents, built for feeds, inboxes, scrape batches, and receipt piles. It names the sibling alternative ai-extract, though it does not explicitly spell out when-not-to-use cases such as handling more than 10 documents or per-document differing fields.

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 value beyond annotations: no wallet or API key required, prepaid x-credit-token header for unlimited calls, pricing at $0.05/call, and one free all/day. It also discloses the output content and the rug-risk flagging behavior, none of which is in the annotations or 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 core function is front-loaded and the pricing/auth details earn their place despite the dense one-paragraph format. Each sentence adds relevant selection/invocation information, though breaking into shorter segments would improve scanability.

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 zero parameters, an output schema present, and annotations declaring read-only, open-world, and non-destructive behavior, the description supplies the remaining needed context: market scope, output contents, pricing, auth requirements, and access model. An agent has everything needed to select and call this 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?

The tool has zero input parameters, so the baseline is 4; the description correctly adds price, aauth, and scope. There are no parameter semantics to define, and the empty schema is fully covered.

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?

Description states a specific verb+resource: Claude writes a concise market brief of Base tokens, aggregating trending and newly-listed tokens. It says what the output covers (mood, highlights, launches, cautions) and distinguishes itself as the zoom-out flagship versus granular lookups.

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 clearly frames the use case: one call provides a trading agent market context instead of dozens of lookups, so it's for broad market situational awareness rather than detailled single-token analysis. It does not name specific alternative tools or enumerate when-not-to-use cases, so not 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 mark this read-only and idempotent, and the description goes well beyond them by disclosing the 16K character ceiling, the 3-5 bullet output shape, JSON return format, per-call pricing, and the x-credit-token/auth model. This adds genuinely useful behavioral context and does not contradict the annotations.

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

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

The core transformation is front-loaded and the pricing/auth details are relevant to correct invocation, so they earn their place. The prose is dense and promotional, which slightly reduces scannability, but no sentence 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?

For a simple one-input summarization tool with an output schema and rich annotations, the description covers input, output shape, size limits, cost, authentication, and usage context. Nothing critical is missing for an agent to select and invoke the tool correctly.

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

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

The schema already provides 100% coverage for the single text parameter, so the baseline is 3. The description adds meaningful constraint information beyond the schema, namely the 16K character limit and the expected JSON bullet output. For a one-string-parameter tool, this is sufficient and helpful.

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

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

The description clearly states a specific job: compress arbitrary text into 3-5 bullet points, with an explicit 16K character limit and clean JSON output. It also distinguishes itself as the 'digest step' for agent pipelines, which sets it apart from siblings like ai_extract or ai_translate. The purpose is unambiguous and actionable.

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

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

It explicitly frames when to use the tool: as a digest step for agents that need to compress content they can't carry in context. It also clarifies entry requirements ('no API key, no prompt engineering'), which is useful. However, it does not name alternatives or state when not to use it, leaving some inference to the agent.

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 annotations, the description discloses important operational behavior: it is a paid x402 call at $0.12, supports a prepaid x-credit-token header for unlimited calls, offers one free call per day, and requires no wallet or API key. It also describes the synthesis and verdict range, adding meaningful context not present in annotations.

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

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

The description is information-dense and front-loads purpose before pricing and requirements. The promotional phrasing 'agent-ready intelligence you can't get free' and 'flagship report' add minor noise, but the overall structure is efficient and well organized.

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

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

For a single-parameter, read-only tool with an output schema, the description covers purpose, required input, output nature, pricing, auth/access options, and the absence of wallet/API-key requirements. Agents have enough information to select and invoke the tool correctly without further inference.

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

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

The schema already fully documents the single 'address' parameter, giving a baseline of 3. The description goes slightly further by specifying that the address refers to a Base token and that it is the required input, which adds network context not explicit 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?

The description specifies a clear verb and resource: produces a Claude-written due-diligence verdict for a Base token, aggregating token risk, holder concentration, price/liquidity, and OFAC sanctions into a structured verdict. This distinguishes it from more focused sibling tools by establishing it as the flagship composite report.

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

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

The description gives clear context for when to call it: when an agent needs a consolidated, agent-ready due-diligence verdict on a Base token in one call. It does not explicitly name alternatives or exclusions, so it stops short of a 5, but the use case is well 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, open-world, and non-destructive. The description adds significant behavioral context beyond this: per-call USDC payment, 6K character limit, no wrapper prose in output, x-credit-token header option, and free tier. This is exactly the kind of operational detail an agent needs before invoking a paid primitive.

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

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

The description is longer than average but every sentence carries useful information: core behavior, output cleanliness, use cases, pricing, and auth model. The key function and constraint are front-loaded, with supporting cost and access details following logically.

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

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

The description covers what the tool does, output format, constraints, pricing, and auth requirements, and an output schema exists, so return values need no explanation. The only minor gap is the expected format for the 'to' parameter (e.g., language name vs. ISO code), but overall the definition is robust for a pay-per-call 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% with both parameters described, so baseline is 3. The description adds value by specifying the 6K character limit for text, stating that 'to' accepts any language, and emphasizing that text is required. This supplements the schema meaningfully without redundancy.

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?

Description states a specific verb ('Translate'), resource ('up to 6K chars to any language'), and output behavior ('get only the translation back'). It clearly distinguishes itself from siblings like ai_summarize and ai_extract by focusing on machine translation with a clean, pipeable output.

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 names concrete use cases: localizing content, parsing foreign-language sources, and serving multilingual users. It does not explicitly name alternatives or exclusions, but the intended context is clear enough for an agent to select this tool over unrelated siblings.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds meaningful context beyond annotations: pricing, billing mechanism, free-tier allowance, lack of wallet/API key requirements, and the categories of output (action, risk read, notes). No contradiction with annotations.

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

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

The description is well-structured and front-loaded with the core purpose. It includes billing and access details that are operationally relevant, and each sentence adds useful information without excessive fluff or repetition.

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

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

For a single-parameter tool with an output schema and read-only annotations, the description covers the essential invocation details: required input, network context, output contents, pricing/auth behavior, and access requirements. The agent has enough information to call and interpret the tool correctly.

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

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

Schema description coverage is 100% and the sole parameter 'hash' is documented in the schema. The description adds mild value by specifying it must be a Base transaction hash and that it is required, but it does not deeply expand on format or validation rules beyond the schema.

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

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

The description clearly states the verb ('explains') and resource ('any Base transaction'), and specifies the output type ('plain-English explanation'). It distinguishes itself from raw-decoding siblings like tx_decode by emphasizing that it turns raw calldata into an answer with risk reads and notes.

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 use case is clear: give a Base transaction hash and receive an explanation of what it actually did. It states the required input and describes what the output covers, but it does not explicitly contrast itself with sibling tools or state when not to use it.

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

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

Beyond the safe-read annotations, the description discloses operational behavior: it is priced per call, runs over x402 on Base, supports a prepaid header for credits, offers a free daily call, and requires no wallet or API key. It also clarifies that the audit is AI-generated by Claude, which is useful expectations-setting for an agent.

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

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

The text is front-loaded with the core purpose and outcome, then covers usage context, required input, and cost/access in compact clauses. The pricing and header details add length but are decision-relevant; still, the hook phrase is slightly redundant with the second sentence.

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

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

For a one-parameter tool with a rich output schema, the description covers inputs, outputs at a high level, use case, cost, payment method, and prerequisites. There is no needed context an agent would lack for selecting and invoking it.

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

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

Schema coverage is 100% and the only parameter, address, is already described as 'Wallet address.' The description reiterates that address is required but adds no format, chain, or normalization details beyond the schema, so it sits at 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?

The description opens with a concrete outcome ('What can drain this wallet — and what to revoke') and states a specific verb-resource pair: pull a wallet's active token approvals and produce a security audit with risk level, USD at risk, and revoke recommendations. This is clearly differentiated from sibling tools by focusing on token approvals and revocation rather than generic address or contract intelligence.

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

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

It explicitly defines when to use it: 'The wallet-safety check agents and users run before trusting an address.' It does not name alternatives or state when not to use it, which prevents a 5, but the trigger condition 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 already declare read-only, open-world, and idempotent behavior. The description adds useful non-obvious context: $0.05 pricing, Base network scope, the prepaid x-credit-token header for unlimited calls, the one-free-call-per-day limit, and the fact that no wallet or API key is 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?

The core ranking behavior and returned queue are front-loaded, with cost and authentication details compactly appended. The opening phrase 'Which approvals could drain you — and revoke order —' is slightly awkward, but the rest is information-dense and avoids repetition.

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

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

For a single-parameter, read-only tool, this covers the essential decisions: what it ranks, what it returns, how it is priced/authed, and which network it runs on. It does not spell out the exact return-team structure, but with no output schema present that is a relatively minor gap.

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

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

The only parameter, address, is already described in the schema as 'Wallet address,' and the description merely restates it as required. With 100% schema coverage, the description adds no new parameter-level meaning or format 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?

The description is specific: it 'ranks a wallet's active token approvals' by a defined risk formula and 'returns a prioritised revoke queue,' so an agent can tell it is an approval-exposure advisory tool. It does not explicitly name and contrast a sibling, but the revoke-advice framing distinguishes it from execution-style tools like revoke_builder.

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

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

The description gives clear application context — 'Approvals are the #1 drain vector; this tells an agent exactly what to revoke first' — plus the required address input and cost/access model. It does not state exclusions or name alternatives explicitly, so it stops short of a complete routing guide.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context beyond that: it clarifies the semantic distinction between allowlist and blocklist policies, notes per-scope behavior, and discloses pricing/auth requirements. No contradiction with annotations.

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

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

The description is longer than strictly necessary, with some rhetorical framing and repeated explanatory asides, but the core semantic distinction is front-loaded and the pricing/auth details are practically useful. It earns its length despite minor redundancy.

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

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

Given the output schema is present, the single parameter is fully documented, and annotations cover the read-only/idempotent safety profile, the description provides everything needed to invoke correctly: input, policy semantics, scope behavior, related sibling, cost, and authentication 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?

Schema coverage is 100%, with the single 'address' parameter already described as 'B20 token address'. The description only restates 'Required input: address' and does not add new format, validation, or behavioral detail, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific operation: decoding whether a B20 transfer policy is a BLOCKLIST or ALLOWLIST, per scope (send/receive/execute/mint). It also explicitly distinguishes itself from b20_safety, which only flags that a policy exists rather than decoding its type.

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

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

The description explains when this tool is needed versus b20_safety: use b20_safety to detect that a policy exists; use this tool to decode the policy type. It also specifies the required input (address) and gives cost/access context (pricing, prepaid header, no API key needed).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds meaningful context: data comes from CDP-indexed events, distinguishes active vs ended announcements, and explains the x402 payment requirement with prepaid-header and free-call options. This is valuable beyond the annotations.

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

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

The description is information-dense and starts with the core purpose, which is good. However, it packs many distinct topics—announcement structure, indexing source, issuer-communications positioning, pricing, payment options, rate limits—into a single run-on paragraph, making it harder for an agent to parse the most decision-relevant facts quickly. It could be split into purpose and usage/pricing sections.

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

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

The tool has one parameter, full schema coverage, and an output schema, so the description doesn't need to explain return values. It covers the data source, the active-vs-ended distinction, the payment mechanism, and the target use case. Minor omissions are things like chain/network specificity and what to do if the address has no announcements, but these are not critical given the output schema exists.

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%: the only parameter, address, is described as 'B20 Asset token address'. The description adds no additional format, chain, or example details for the address, so it doesn't raise the score above the baseline. The description does reinforce that address is the required input, but that's already 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?

The description clearly identifies the tool as reading on-chain issuer notices and corporate actions for B20 Asset tokens, and explicitly contrasts it with ERC-20 channels, which helps distinguish it from sibling tools. The verb 'Reads a token's announcement feed' plus the concrete 'Announcement: id, description, uri' structure makes the resource and operation unmistakable.

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

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

The description tells the agent this is the issuer-communications primitive for B20/RWA token holders and states the required input (address) and pricing model. It doesn't explicitly name alternative tools or state when not to use it, but the B20-specific scope and 'ERC-20 has no equivalent for' contrast imply the appropriate context. The pricing and free-tier guidance also help the agent decide whether to call it.

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

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

Beyond the readOnly/idempotent annotations, the description discloses how the check works (factory registration and bytecode absence), why it cannot be spoofed (chain-native precompile authority), and what verdicts it returns (genuine / fake_lookalike / not_b20). This gives the agent a clear mental model of the tool's behavior.

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

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

The essential content is front-loaded and the threat-model explanation is useful, but the later pricing and marketing sentences ('The 2-cent check,' prepaid header, free call/day, no wallet/API key) go beyond the core definition. It is not bloated, but it is longer than a strictly concise tool description needs to 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 a single parameter, a present output schema, and strong annotations, the description adds is the missing context: why the check matters, what authority it relies on, what verdicts to expect, and how access/cost works. Nothing critical for calling the tool correctly is missing.

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

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

The single address parameter is already fully described in the schema as 'Token address,' so the description has little additional semantic burden. It only repeats 'Required input: address' and does not add format, chain, or constraint details, making 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?

The description opens with the precise question 'Is this a REAL B20 — or a lookalike contract?' and then states the concrete verification: 'factory registration + bytecode absence.' It clearly identifies the tool as the authenticity gate for B20 tokens, and the mechanism distinguishes it from other B20 tools like b20_info or b20_access_type.

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

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

It explicitly commands 'Run FIRST on any B20' and says it 'keeps every other B20 answer honest,' making the when-to-use decision unambiguous: this tool precedes all other B20 analyses. No alternative is named because this is the designated first-step authenticity 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 establish readOnly, idempotent, and non-destructive behavior; the description then adds meaningful context: the worst-score aggregation, the per-call cost, the x-credit-token payment option, free-tier limit, and that no wallet or API key is needed. This goes well beyond the structured annotations without contradicting them.

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

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

The core purpose is front-loaded and the description is information-dense without being bloated. Minor redundancy exists between 'Freeze/seize scan' and the repeated list of scoring dimensions, but every sentence contributes useful operational or pricing context.

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

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

Given the simple one-parameter input schema, high schema coverage, and existing output schema, the description provides everything an agent needs to invoke the tool: purpose, cardinality limit, input requirement, pricing/authentication model, and safety profile. No critical operational detail is missing.

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

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

The input schema fully documents the 'addresses' parameter format (comma-separated B20 addresses), so the baseline is 3. The description adds a valuable constraint not in the schema: the batch supports 'up to 5' tokens, and clarifies the evaluation dimensions (freeze/seize/pause/rebase/uncapped-mint).

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?

Clearly states a specific action ('freeze/seize scan') and resource ('up to 5 B20 tokens'), then adds scoring dimensions. It differentiates from single-token siblings like b20_safety by emphasizing the batch capability and the one-call nature.

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 scopes usage to 'portfolio holders and agents screening several B20s at once,' giving clear context for when the batch tool is appropriate. It does not explicitly name a single-token alternative or state when not to use it, so it loses a point.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavior beyond those: it explains the failure mode the tool guards against, the verdict vocabulary, the pricing model, the prepaid header, the free daily call, and the fact that no wallet/API key is needed. No contradiction exists.

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

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

The description packs a lot of useful information into a single dense paragraph, including purpose, output, pricing, and access requirements. It is slightly florid at the start ('Bricked scopes, dangling policies, frozen lists') and mixes pricing into the behavioral description, but every sentence contributes actionable content.

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 audit tool with a rich output schema and clear annotations, the description is complete: it states the required input, enumerates the verdicts, highlights the key output flag, explains the real-world failure mode, and gives the authentication/billing context. Nothing critical is missing for an agent to select and call it correctly.

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

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

Schema description coverage is 100%, and the schema already defines address as 'B20 token address'. The description only repeats 'Required input: address' without adding format, chain, checksumming, or example details, so it meets the baseline but adds no semantic value beyond the schema.

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

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

The description names a specific action ('Audits every policy scope for dangling bindings, ALWAYS_BLOCK, renounced lists and live pauses') and a concrete resource (B20 token configuration). It also differentiates the tool by naming its output verdicts and a distinctive 'can-this-token-even-move' flag, which separates it from sibling b20_* tools like freeze_check or 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?

The description gives clear usage context: 'Pre-launch lint for issuers, stuck-funds guard for holders and merchants.' It implies when to use the tool across the token lifecycle but does not explicitly name alternatives or state when not to use it, leaving some routing burden on the agent.

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

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

Annotations already mark readOnly/openWorld/idempotent/no-destructive. The description adds meaningful behavioral context: it reads onchain role events, reports controller specificity, centralization, and admin renouncement, and discloses access requirements (pricing, x-credit-token header, no wallet/API key). No contradiction with annotations.

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

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

Every sentence contributes: the purpose question, sibling contrast, data source and outputs, use case, input reminder, and access/cost. It is longer than minimal but justified by the amount of useful context; minor redundancy with schema's required-address note keeps it from a 5.

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

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

For a single-parameter read-only audit tool with a full output schema and safety annotations, the description supplies everything an agent needs: what it reports, when to use it, what input it expects, and how to access it. No important gaps.

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

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

The only parameter, address, is fully described in the schema as 'B20 token address' (100% coverage). The description reiterates 'Required input: address' and contextualizes the target as 'this B20', but adds no format or syntax detail, so it stays at baseline 3.

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

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

States a specific verb ('Reads the token's role-based access control... reports the exact controllers'), a specific resource (B20 token roles), and immediately distinguishes from sibling b20_safety ('WHICH powers' vs 'WHO holds them'). The opening question 'WHO can mint, seize, freeze or pause this B20?' makes the purpose unmistakable.

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

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

Explicitly contrasts with b20_safety, telling an agent to use this when it needs WHO holds powers rather than WHICH powers exist. Also gives a concrete trigger: 'The issuer-control map an agent needs before holding a regulated Base-native asset.' This provides clear selection criteria.

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?

There are no annotations, so the description carries full responsibility, and it delivers: it discloses the Base chain, per-call pricing, x-credit-token header option, free daily allowance, and that no wallet or API key is required. It also reveals that Claude writes the verdict and that real seizure history is incorporated.

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 dense but purposeful: it front-loads the core purpose, then lists report components and verdict output, then closes with required input, pricing, and auth. A little more bullet-style structuring would improve scannability, but every sentence contributes useful selection or invocation information.

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

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

For a one-parameter report tool with an output schema, this is complete: it covers purpose, report content, input requirement, chain, pricing, authentication, and rate-limit behavior. Nothing needed to decide whether to call it or 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% and the schema already describes address as 'B20 token address.' The description only repeats 'Required input: address' and adds no format, checksum, or chain-specific detail beyond what the schema provides, so it rests at 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?

The description names a specific deliverable — an institutional AI report on a Base-native B20 token — and enumerates exactly what it composes and what verdict it produces. It also differentiates itself within the sibling suite by calling itself the 'premium tier' and stating that 'no ERC-20 tool can produce it.'

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

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

It clearly identifies the intended context: institutional due-diligence on a B20 token requiring a hold/avoid recommendation. It does not name direct alternative b20_* siblings or state explicit when-not-to-use conditions, but the use case is concrete enough for an agent to select it appropriately.

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, idempotent=true, openWorld=true, and destructiveHint=false, so no contradiction. The description adds useful behavioral context beyond annotations: it explains the policy being checked, the seizable consequence, pricing, and that 'No wallet or API key required.' It doesn't describe response contents, but output schema is available to cover that.

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

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

The core behavior is front-loaded in the opening question and immediately explained in the next sentence. The pricing and free-tier information is extra but useful for agents handling cost-sensitive calls. The wording is a bit promotional but each sentence contributes either behavior, usage context, or prerequisites.

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 annotations cover safety and an output schema exists, this description is complete enough: it states the tool's purpose, the use case, the relationship to b20-safety, required inputs, pricing, and access constraints. It doesn't explain the finer meaning of 'transfer-sender policy,' but that is an implementation detail rather than a blocker for selecting or invoking the 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?

Input schema coverage is 100% and already documents both 'token' and 'wallet' with types and descriptions. The description adds no new parameter-level detail beyond saying they are required inputs and framing 'wallet' as 'YOUR wallet,' so it doesn't significantly extend 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 uses a specific verb ('Checks whether') and a clear resource ('a B20 token's transfer-sender policy'), explaining what the tool does and the consequence of being unauthorized ('can't transfer and can be burnBlocked() (SEIZED) by the issuer'). It also distinguishes itself from the sibling b20-safety by calling itself the 'personal companion' for checking 'MY funds,' so an agent can tell it apart.

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

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

The description explicitly positions this tool against b20-safety with 'The personal companion to b20-safety — can this token freeze MY funds?', giving clear contextual guidance for when to use it. It doesn't enumerate exclusions or contrast with other b20 siblings like b20_transfer_preflight, so it stops short of full when-not-to-use instructions.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable operational context beyond those: the tool returns an auditable receipt, requires no wallet or API key, costs $0.10 per call, and has a free daily quota. The references to seize, freeze, rebase, pause, and uncapped-mint are framed as checks aggregated into a verdict, not mutations, which is consistent with the non-destructive annotations.

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

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

The description is front-loaded with the core purpose and get progressively operational. The pricing, free-call limit, and no-wallet/no-API-key details are useful for an agent deciding whether to invoke the tool. It is somewhat verbose and promotional ('The B20 tool to bind first'), but each sentence contributes meaningful selection or invocation context.

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

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

The tool has a rich output schema and strong annotations, so the description does not need to explain return values. The description sufficiently covers when to use it, what checks feed the verdict, how to use the optional wallet parameter, and cost/authentication requirements. It is complete enough for correct invocation, though it could briefly mention the GO/HOLD/STOP semantics or point to a sibling for deeper checks.

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

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

The schema already describes both parameters with 100% coverage. The description reiterates that address is required and wallet is optional for checking blocked status, but it adds little meaning beyond the schema. Baseline 3 is appropriate because the description does not need to compensate for missing schema 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?

The description clearly states this is a pre-trade gate that produces a GO/HOLD/STOP verdict by aggregating multiple B20 risk checks (seize, freeze, rebase, pause, uncapped-mint). It communicates the resource (Base-native B20 tokens) and the core action (assessment before trading). However, it does not explicitly differentiate from sibling tools like b20_safety or pre_trade_gate, making it clear but not fully distinct.

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

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

The description provides explicit usage context: it is the call to make before touching a B20 token, and it should be the first B20 tool to bind. It also explains the optional wallet parameter for checking if the user is blocked. It does not mention when not to use it or name specific alternatives, so it stops shot 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/openWorld/idempotent/destructive=false, and the description adds the important context that it reconstructs historical state from a privileged one-time window, costs $0.04, and requires no API key. It doesn't describe return structure or failure modes, but with annotations covering safety, this is solid.

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 dense but every sentence adds value: explains the niche window, what is reconstructed, verdicts, input, and pricing/auth. It is slightly long but the content justifies it; front-loads the unique value proposition.

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 one param with full schema coverage, no enums, and an output schema present, the description covers what the tool does, why it is unique, how to call it, and its cost/auth requirements. Nothing meaningful is missing.

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

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

The single parameter 'address' is fully schema-documented as 'B20 token address'. Description reinforces what the tool does with that address. With 100% schema coverage, baseline 3, and the description adds meaningful context (what it inspects for that address), so 4 is appropriate.

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

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

States a specific verb ('reconstructs'), resource ('initCalls bypass window' of createB20), and deliverable ('token's true starting conditions', verdict categories). Clearly distinguishes from siblings like b20_config_audit or b20_mint_watch by focusing on the one-tx issuer-only window.

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 explains what the tool analyzes and the verdict categories, and mentions pricing/auth model. It does not explicitly name alternatives or when-not-to-use, but the narrow scope is implicitly clear; still, explicit exclusion of e.g. 'use b20_mint_watch for ongoing minting' would be stronger.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context beyond that: sub-second real-time event capture, the distinction between status lookup and network feed, pricing per call, free-tier limits, and the fact that no wallet or API key is required. No contradiction with annotations.

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

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

The description is dense and well front-loaded, with the core purpose first followed by usage modes, pricing, and auth requirements. Minor redundancy exists ('real-time... moment' + 'sub-second', 'network-wide' + 'across all of Base'), but every sentence contributes useful information.

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

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

For a single optional parameter with an output schema and read-only annotations, the description is fully sufficient. It covers invocation modes, network scope, event triggers, billing, auth, and free-tier access. There are no meaningful gaps that would prevent an agent from calling the tool correctly.

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

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

The input schema already fully documents the optional address parameter, so the baseline is 3. The description adds meaning by clarifying that providing an address returns live guard status and omitting it returns the seizable-token feed. This goes slightly beyond the schema but does not specify address format or chain requirements.

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

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

The description clearly states a specific verb and resource: it delivers real-time alerts when a B20 token becomes seizable. It further distinguishes itself from the sibling b20_policy_watch by describing itself as the 'live layer' with sub-second webhook capture of PolicyUpdated/Paused events.

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

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

The description gives explicit usage modes: pass an address for live guard status, or omit it for the network-wide feed of tokens that just became seizable. It lacks explicit 'when-not-to-use' or alternative tool routing beyond referencing B20 Policy Watch, but the call patterns are unambiguous.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is well covered. The description adds valuable operational behavior: the $0.02 cost per call, the x-credit-token header for unlimited calls, the 1 free call/day per tool, and the explicit statement that no wallet or API key is required. This goes well beyond the annotations and gives an agent concrete expectations about auth, rate limits, and cost.

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

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

The description is front-loaded with the core purpose and field list, then moves to operational details like pricing and auth. It is reasonably compact for the amount of information conveyed. There is minor redundancy in 'Full profile... Complete B20 token profile,' but it does not seriously hurt readability.

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

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

For a single-parameter read-only tool with an output schema, the description covers the essentials: what data is returned, what input is required, the data source, pricing, auth requirements, and the relationship to b20-safety. The main gap is the lack of explicit routing among the large family of b20_* data tools, but this is a minor weakness given how clearly the scope is defined.

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

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

The schema already provides 100% coverage for the single 'address' parameter with the description 'B20 token address.' The tool description merely repeats 'Required input: address' without adding format, chain, or example-level detail. With complete schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly opens with 'Full profile of a Base-native B20 token' and itemizes the exact fields returned: variant, name, symbol, decimals, total supply, supply cap, transfer policies, pause states, and rebase. It also positions itself as 'The data companion to b20-safety,' which distinguishes it from at least that sibling. However, it does not explicitly differentiate itself from other closely related data tools like b20_metadata, b20_supply, or b20_dossier.

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

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

The description implies usage as the data counterpart to b20-safety and states that only an address is required, but it never gives explicit when-to-use or when-not-to-use guidance relative to the many overlapping b20_* sibling tools. No alternatives besides b20-safety are mentioned, and there is no exclusion such as 'for safety assessment use b20_safety 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 read-only, idempotent, open-world, and non-destructive behavior. The description adds meaningful context beyond that: freshness, source precompile, return fields, pricing, rate limits, auth requirements, and the safety caveat that new tokens are not necessarily safe. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose and remains information-dense without fluff. Each sentence adds value: technical origin, returned fields, use case, safety warning, pricing, and access method. The structure is easy to parse.

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

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

The description covers the essential operational details: what is listed, where it comes from, what fields are returned, pricing, auth, and a safety follow-up. Minor gaps include unclear limit semantics and no explicit pagination or ordering details, but for a simple discovery list this is nearly 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?

Schema coverage is 100%, so baseline is 3. The only parameter, 'limit', has a minimal 'How many' description, and the tool description does not clarify limits, defaults, or formatting. The description adds no real parameter meaning 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?

The description clearly states the tool lists newly created B20 tokens on Base from the B20Factory precompile, with a specific verb and resource. It conveys the discovery-feed purpose but does not explicitly differentiate itself from closely related siblings like b20_mint_watch or new_tokens.

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

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

The description gives clear context: it is a discovery feed for agents hunting new B20 launches early, and it instructs users to run b20-safety before touching any address. It does not explicitly list alternative tools or exclusion conditions, but the use case is well conveyed.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive, so the safety profile is established. The description adds valuable context about the read behavior, optional filters (memo or caller), required address input, and operational details like pricing and no wallet/API key required. No contradiction with annotations.

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

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

The description is reasonably concise and front-loads the core purpose, followed by the read behavior, filtering, use case, and access requirements. Some phrases (e.g., 'a field ERC-20 has no equivalent for') are explanatory color rather than essential, but most 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?

Given a simple 3-parameter schema with 100% coverage, an output schema, and strong annotations, the description supplies everything else an agent needs: the required input, optional filters, the B20-specific use case, and the pricing/access model. There are no critical gaps for selecting or invoking the tool correctly.

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

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

Schema description coverage is 100%, so the schema itself already explains the address, memo, and caller parameters. The description adds little beyond restating that an address is required and that memo is bytes32 and caller is a wallet — both already encoded in the 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 action and resource: it 'Reads a token's on-chain Memo event history' and clearly explains what B20 memos are for. It names the underlying primitive (transferWithMemo) and contrasts it with ERC-20, which helps distinguish this tool 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?

The description provides a clear use case: 'The settlement-reconciliation primitive for agents paying over B20 stablecoins.' This tells an agent when to select this tool. However, it does not name alternative tools or explicitly state when not to use it, so it lacks full exclusion guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description aligns with those. It adds useful behavioral context beyond annotations by explaining the two exact checks (mutability role and rename history), the impersonation/bait-and-switch risk, and operational details like pricing and lack of API key requirement. No contradiction exists.

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

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

The description is reasonably sized but includes a rhetorical question and explanatory framing that add length without functional content. The core behavior is present and clear, but pricing and operational details could be separated or streamlined. It is structured acceptably, but not every sentence earns its place.

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

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

With a single required parameter fully documented, an output schema present, and annotations covering safety, the description provides sufficient operational context: what is checked, required input, chain (Base), pricing, and authentication. Since an output schema exists, return values need not be explained. It misses explicit usage guidance, already penalized separately.

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

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

The input schema fully documents the only parameter as 'B20 token address,' giving 100% schema coverage. The description merely repeats that address is required and does not add format, constraints, or examples. This matches the baseline of 3 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 clearly states a specific read operation: checking whether B20 metadata is mutable (a METADATA_ROLE holder exists) and whether the token has already been renamed on-chain. This distinguishes it from many b20_* siblings by topic, though it does not explicitly name an alternative tool, so it falls short of the top bar.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description says what it reads and gives operational details, but an agent must infer the appropriate use case from context. No exclusions or alternative tool names are provided.

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

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

Annotations already mark the tool read-only and non-destructive, and the description adds substantial behavior: it reports every mint including batchMint, includes amount/recipients/share-of-supply, and classifies into heavy_dilution/active_minting/minor_minting/quiet. It also discloses pricing, the x402 payment path, the optional prepaid header, and the fact that no wallet or API key is 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?

The description is front-loaded with the core purpose and keeps most sentences useful. Some phrasing is promotional/redundant, such as 'The live issuance feed for agents holding B20 stablecoins and RWAs,' which restates the earlier point, but overall it is compact for the amount of context it carries.

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

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

There is an output schema, so return shape does not need explaining. The description covers purpose, differentiation from a sibling, required and optional parameters, default window, behavioral categorization, pricing, auth model, and fee-free path. An agent has enough to invoke this correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the days range (1-90) and notes that address is required, but it mostly repeats what the schema already states. It does not materially deepen parameter understanding beyond a small range clarification.

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

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

The description names a specific resource (B20 token mint events) and an active verb ('shows the actual printing', 'live issuance feed'). It explicitly distinguishes itself from b20_supply, which covers the dilution ceiling, so an agent can tell these siblings apart.

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

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

The description gives clear context: use this to see actual mint activity rather than the supply ceiling, and it names b20_supply as the contrasting alternative. It also states required input and the days window. It does not enumerate exclusion cases, but the guidance is strong enough for correct selection.

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

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

Annotations already mark this read-only/idempotent, and the description adds genuinely useful behavioral context: the five distinct return categories, edge cases (no market price, non-USD pegs), zero price discovery for 'pure claim' pegs, and the auth/pricing model (prepaid header, free tier, no wallet/API key). It is consistent with the readOnlyHint annotation.

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 dense but front-loaded: the core concept and distinct output states appear first, with usage context, required input, and pricing following. Every sentence adds information, though the pricing/auth sentence is somewhat promotional for a tool-description context.

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

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

With one parameter, no nested objects, and an output schema present, the description covers everything needed to invoke correctly: input, output categories, edge cases, when to run it, and network/costing specifics. Nothing material is missing for an agent to decide and call this 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%—the only parameter 'address' is already documented as a B20 stablecoin address. The description repeats that requirement and adds marginal context (calls run over x402 on Base), but introduces no meaning the schema doesn't already convey, so it lands at 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?

The description states a specific action—comparing a B20 stablecoin's self-declared peg against actual DEX market pricing—and names the exact output states (on_peg, depeg_warning, depegged, no_market, unverifiable_fx). It clearly differentiates itself in the B20 tool family by positioning itself as 'the missing check' that the B20 standard does not perform.

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

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

The description gives a concrete trigger ('Run before settling in any B20 stablecoin') and explains the underlying problem (currency() is self-declared and unverified). It does not name specific sibling tools to use instead or explicitly exclude alternatives, but the strong use-case framing makes when-to-call 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?

Beyond the readOnlyHint and idempotentHint annotations, the description explicitly says 'Read-only — signs nothing', enumerates the exact data returned, and discloses pricing, auth requirements ('No wallet or API key required'), and free-tier availability. This gives agents concrete expectations for invocation and side effects.

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 somewhat long but front-loaded with the core purpose and backs it with essential operational details like pricing and auth. Each segment adds value; only the pricing clause feels slightly verbose relative to the technical core, but it is still useful for an agent deciding whether to call.

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 output schema exists and the annotations cover safety, the description supplies all necessary operational context: what data is read, that it is read-only, required input, pricing model, free tier, and absence of auth prerequisites. An agent can correctly select and invoke this tool without missing critical information.

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 both 'address' and 'owner', so the baseline is 3. The description adds meaningful context by explaining the nonce's purpose ('so the signed payload can't be rejected/replayed') and clarifying 'Required input: address', which helps an agent understand why each parameter exists and which is mandatory.

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

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

The description clearly states the tool reads ERC-2612 permit data for B20 tokens, naming the exact resources: DOMAIN_SEPARATOR, owner nonce, and EIP-712 domain/type struct. It uses 'Read-only' and 'signs nothing' to distinguish from approval transactions, making the purpose unmistakable even among 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?

The description provides clear context: the tool is for gasless-approval readiness and for building valid permits via signature instead of a transaction. It does not explicitly name alternative tools or state when-not-to-use conditions, but the intended scenario is well implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description does not need to restate safety. It adds useful non-obvious behavioral context: pricing per call, the x-credit-token header option, the free daily call, and that no wallet or API key is required. No contradiction with annotations.

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

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

The description contains useful information but is padded with rhetorical framing like 'WHO administers the blocklist that can freeze you?' and 'straight from the registry.' The pricing and header details are valuable, but the overall text could be tighter without losing meaning.

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

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

For a single-required-parameter read-only tool with an output schema present, this description is sufficiently complete. It explains what data is read, which sibling it is distinct from, authentication/pricing expectations, and the required input. Minor gaps like exact output shape are covered by the output schema.

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

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

The schema already documents 'address' as 'B20 token address' with 100% coverage, so the description adds little beyond repeating that address is required. This matches the baseline of 3 for high schema coverage; the description does not meaningfully enrich the parameter 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 and resource: it 'reads WHO administers each active transfer/mint policy (policyAdmin)' and whether control is being handed over or renounced. It also distinguishes itself from b20-control by clarifying this tool queries the Policy Registry rather than the token's own roles, so an agent can tell them apart.

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

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

The description gives clear context for when this tool is relevant, noting it is the 'other half' of freeze/seizure authority and contrasting it with b20-control. It does not explicitly list exclusions or say 'use when X instead of Y,' but the alternative is named and the distinction 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 cover read-only, idempotent, and non-destructive. The description adds meaningful context beyond those: the event-replay mechanism, the fact that no wallet or API key is required, and the commercial terms ($0.05 per call over x402 on Base, x-credit-token header for unlimited calls, 1 free call/day). These operational details help an agent decide whether and how 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 most important contrast (FULL list vs one wallet) is front-loaded in the first sentence, and every subsequent clause adds a distinct fact: mechanism, output contents, invocation, pricing, auth. A few phrases are promotional ('Compliance-grade visibility no other tool provides') and the pricing block is long relative to the core description, but there is little true 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 needn't be spelled out, and this is a complex tool: two alternative invocation modes, historical replay, per-scope member sets, and commercial terms. The description handles nearly all of that. The noticeable gaps are the zero-required--params case (no guidance on what a no-arg call returns) and 'per scope' being left undefined.

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% but each parameter description is thin ('Registry policy ID' / 'B20 token address'). The description adds the key semantic: the parameters are alternatives ('Pass address= (token) or policy= (registry policy ID)'), an either/or relationship the schema does not convey. It does not clarify what happens if neither optional parameter is passed.

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 and resource: it 'Replays the Policy Registry's BlocklistUpdated/AllowlistUpdated events into the full membership of a B20's blocklist/allowlist' and enumerates the WHOLE list with history. It explicitly distinguishes itself from b20_freeze_check ('answers one wallet; this enumerates the WHOLE list'), so an agent can tell them apart immediately.

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

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

Names the key alternative (b20-frozen-check) and the condition that selects this tool: one wallet's status vs the entire list. It also gives invocation guidance ('Pass address= (token) or policy= (registry policy ID)'). It doesn't address other potentially overlapping siblings like b20_policy_watch or b20_policy_admin, so it's 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?

The annotations already mark the tool as read-only, idempotent, and non-destructive; the description adds valuable behavioral context by disclosing the exact onchain data sources, the computed outcome (if/when the token turned seizable), and operational details such as x402 pricing, prepaid credit header, free tier, and no wallet/API key requirement. No contradiction with annotations.

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

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

The description is front-loaded with the key question and then efficiently moves through mechanism, behavior, required input, pricing, and authentication. Each sentence adds a distinct piece of operational or diagnostic information, so the relative length is justified and there is 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?

With one required parameter fully documented, an output schema present, and the description covering data source, output intent, chain, payment, auth, and free-tier behavior, the agent has everything needed to correctly select and invoke the tool. No critical operational gap is evident.

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%; the schema already documents address as 'B20 token address.' The description only repeats 'Required input: address' and does not add format, validation, or chain-specific meaning beyond the schema, so the baseline score 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 opens with a precise diagnostic question, 'Did this token BECOME seizable after launch?', and then gives the exact mechanism (PolicyUpdated leading to burnBlocked) and the data read (policy/pause event timeline plus live policy state). This makes the tool's purpose highly specific and clearly distinguishes it from generic B20 tools by framing it as the 'B20-only rug vector.'

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 intended scenario is clearly implied: use this when you need to determine whether a B20 token became seizable after launch. However, the description does not explicitly state when not to use it or mention any sibling alternatives, so the usage guidance relies on inference rather than direct routing.

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

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

Annotations already declare readOnly and idempotent behavior, and the description adds useful details: it scans the wallet for protocol-level freeze/seize powers, checks whether the address is already blocked, and returns rebase flags. It also discloses pricing and authentication requirements, which are useful operational behaviors.

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

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

The description is front-loaded with a clear question and purpose, and every major point—input, output, pricing, access—is covered. It is somewhat dense and includes marketing phrashes like 'the risk no ERC-20 portfolio tool can see', but it remains compact enough for an agent to parse quickly.

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

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

Given the single clean parameter, the readOnly annotations, and the presence of an output schema, the description is complete. It tells the agent what the tool does, what input is required, what it returns, and the cost/auth model, with no critical gaps for invocation.

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

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

The schema already fully documents the single 'wallet' parameter as 'Wallet address', and the description simply repeats that wallet is required. The description adds slight context by clarifying the wallet is the one under B20 risk evaluation, but it does not add meaningful detail beyond the schema.

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

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

The description uses a specific verb ('scans') and names the exact resource: a wallet's B20 holdings. It clearly defines the output as per-token freeze/seize/rebase flags plus a wallet-level verdict, making the tool's purpose easy to distinguish from generic portfolio tools.

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

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

The description clearly states when to use the tool: for agents holding Base positions who need B20-specific freeze/seize risk assessment. It does not explicitly name alternatives or exclusions, but the context is strong enough that an agent would not confuse it with a generic ERC-20 portfolio 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?

Beyond the annotations (readOnlyHint, idempotentHint, openWorldHint, non-destructive), the description adds valuable behavioral detail: stablecoin variants return no-rebase, the call is priced at $0.02 over x402 on Base, prepaid headers are supported, a free daily call exists, and no wallet or API key is required. This gives the agent concrete invocation and cost expectations.

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

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

The description is front-loaded with the core purpose and then covers input, edge-case behavior, network, pricing, and auth in a compact block. The pricing and header details are slightly verbose for a tool description, but they earn their place because they are important for correct invocation.

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?

This is a single-parameter read-only tool with an output schema, and the description covers all essential context: what it reads, what it flags, stablecoin edge case, required input, network/chain, cost, billing options, and authentication. 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%, so the schema already fully documents the single 'address' parameter as a B20 token address. The description adds the 'Asset-variant' context and the stablecoin caveat, but does not add meaningful parameter format or validation details beyond the schema.

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

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

The description uses a specific verb ('Reads') attached to a clear resource ('B20 Asset token's rebase multiplier'), and adds the risk-flagging intent. It also distinguishes stablecoin behavior explicitly, which separates this tool from related B20 variants.

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

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

The description conveys when to use the tool: to check whether an issuer-controlled rebase is invisibly scaling balances, and it notes that stablecoin variants return no-rebase. It does not explicitly name alternative sibling tools, but the context is clear enough for an agent to select it for this read-only rebase risk query.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description discloses important behavioral traits: no transfer, no per-account event, and nothing in tx history, plus explicit flagging of downward moves. It also covers auth and rate-limit context (x-credit-token header, free tier), which annotations do not provide.

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

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

The key differentiation is front-loaded with the striking first sentence, and pricing/auth details are confined to the end. The description is slightly wordy with its em-dash framing, but each sentence contributes distinct, useful information.

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

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

For a single-address read-only history tool, the description covers input, alternative tool, behavioral semantics, use case, pricing, and access constraints. Since an output schema exists, omitting return-field details is acceptable.

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

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

The schema already documents the only parameter at 100% coverage with 'B20 Asset token address'. The description merely repeats 'Required input: address' without adding format, validation, or examples, so the baseline 3 applies.

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

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

The description opens with a distinctive value proposition ('Every silent balance rescaling this token ever did') and states a concrete action: replay the full MultiplierUpdated history and flag downward moves. It also contrasts with b20_rebase, making the tool's purpose unambiguous.

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

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

It explicitly names the sibling b20_rebase as the tool for today's value ('b20-rebase shows today's value; this replays...'), giving an agent a clear selection rule. It also provides the intended context ('before you hold a rebasing RWA') and access prerequisites like address, pricing, and no wallet/API key.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered. The description adds meaningful behavioral context: it reads protocol-level powers (Policy Registry, burnBlocked), explains the B20 standard's difference from ERC-20, and reveals pricing/crediting behavior ($0.04 per call, prepaid header, 1 free call/day, no wallet/API key needed). This goes beyond the annotations and helps an agent understand side effects, costs, and access requirements.

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 dense but has almost no fluff, and the key question ('Can this token freeze or seize your funds?') is front-loaded. The marketing phrases ('The first B20-aware safety check on Base') add some promotional flavor but don't hurt clarity. A couple of clauses could be trimmed, but overall every sentence earns its place by conveying the risk model, input, price, and access model.

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

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

The tool takes one parameter, has a clear output verdict (hold/caution/avoid) and a rich output schema. The description explains what the tool reads, how it differs from ERC-20, how to pay for it, and the free-tier allowance. For a single-address safety check with an output schema, nothing essential 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 parameter 'address' has its own description 'B20 token address'. The tool description also reinforces that the required input is an address. With such high schema coverage and one simple parameter, there's little else needed; the description adds the convention that this is a B20 address, not an EOA or ERC-20 address, which is valuable.

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

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

The description clearly states the tool's purpose: checking whether a B20 token can freeze or seize funds, and producing a hold/caution/avoid verdict. It names the specific resource (B20 token, via an address) and the specific safety attributes (seizable, freezable, paused, rebase, uncapped-mint). This distinguishes it from siblings like b20_freeze_check or b20_seizure_history because it's an aggregate safety verdict rather than a single check.

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

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

The description implies when to use it: when you need a B20 safety check that combines freeze/seize/pause/rebase/mint-risk into one verdict. It explicitly states the required input (address) and the one free call/day, but it doesn't explicitly say when not to use it or which sibling to prefer (e.g., b20_freeze_check for just freeze status, b20_config_audit for deeper config). Clear context, but no explicit 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 mark this as read-only, open-world, idempotent, and non-destructive; the description adds meaningful behavioral context beyond that: it scans actual on-chain seizure events, returns a three-state verdict, covers both single-wallet and network-wide modes, and discloses pricing/auth requirements and free-tier availability. No contradiction.

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

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

The description is front-loaded with the core purpose and differentiator, then moves through the data source, verdicts, and usage. It includes extra details like pricing and API-key-free access, which are useful but slightly beyond the minimal invocation guidance. Overall, it is organized and every sentence adds context.

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

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

Given the output schema exists, the description does not need to explain return values. It covers what the tool does, how it differs from siblings, how to call it in both modes, what the verdict values mean, and important operational details like cost and free-tier usage. This is complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100%, so the schema already explains the wallet and address parameters. The description adds extra meaning by explaining the wallet-scoped vs. network-feed modes and reiterates how to omit the address for a network-wide view. It does not add much beyond the schema, but it reinforces the key usage nuance.

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

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

The description opens with a clear, direct question—'Has this issuer ever actually SEIZED holders?'—and then defines the exact mechanism (scanning the BurnedBlocked event) and output verdicts. It also explicitly contrasts itself with 'every other B20 check,' making it easy to distinguish from siblings.

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

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

The description clearly tells when to use this tool versus other B20 checks: it reports what the issuer has actually done, not what it can do. It also provides concrete instructions for wallet-specific vs. network-wide calls. It does not name specific sibling alternatives, but the contrast is explicit enough.

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

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

The description significantly expands on the annotations by clarifying that the currency code is merely the issuer's declaration, not attested backing, and explicitly lists the inspected control mechanisms: seize/freeze/pause/uncapped-mint. It also discloses pricing, billing behavior via x-credit-token header, and that no wallet or API key is required, which is useful operational context beyond the readOnlyHint and idempotentHint annotations.

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

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

The description is information-dense and front-loaded with the core purpose before moving to the caveat and payment details. It earns its length by explaining the non-attested nature and billing/trial terms, though a slight tightening around the payment sentence could make it even more scannable.

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

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

For a single-parameter read-only tool with a rich output schema and strong annotations, the description covers the what, why, caveat, and invocation context. Nothing needed for correct tool selection or calling 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 address parameter already has a clear description ('B20 Stablecoin address'). The tool description only repeats 'Required input: address' without adding new format, validation, or example details, so it meets the 100%-coverage baseline but does not go beyond 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?

The description clearly states a specific verb and resource: it 'Reads' the declared peg, issuance profile, and control powers of B20 Stablecoin tokens. It also frames the tool as a one-call profile, which separates it from granular siblings like b20_peg, b20_supply, and b20_control.

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 provides clear context: agents settling in B20 stablecoins should use this when they need a one-call 'what is this stablecoin and who controls it' summary. It does not explicitly name alternatives or exclusions, but the one-call framing implies when to reach for this aggregated view instead of separate endpoint calls.

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 open-world behavior. The description adds valuable behavioral context: it reads on-chain SupplyCapUpdated history, interprets cap raises as dilution, and flags uncapped mint as the worst case. This goes beyond the annotation signal without contradicting it.

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 functionality is front-loaded and concise, with useful sibling context. The pricing and x-credit-token header details are relevant for invocation but slightly extend the description beyond what an agent needs for basic selection; still, the structure remains scannable.

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

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

: The tool has one required parameter with full schema coverage, an output schema, and strong annotations. The description closes the remaining gap by explaining how to interpret the data, noting the base chain, and pointing to the complementary b20-control tool. Nothing essential 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 parameter is already described as 'B20 token address.' The description repeats that an 'address' is required but adds no meaningful new format, constraints, or domain detail 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?

The description clearly names the resource and what it does: 'Mint headroom & dilution history of a B20' and 'Reads supply cap vs minted supply.' It further distinguishes itself from siblings by noting 'b20-safety covers seizure' and routing the mint-role question to b20-control.

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

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

It explicitly frames the tool as 'the dilution half of B20 rug risk' and contrasts it with b20-safety's seizure focus. It also tells the agent to 'Pair with b20-control to see who holds the mint role,' which gives concrete orchestration 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 read-only/non-destructive/idempotent, and the description adds substantial context beyond them: the result is live and time-varying ('clears NOW', 'live transfer-pause'), the policy-resolution semantics per participant (sender policy vs. from, receiver policy vs. to, executor policy vs. operator), and service behaviors — $0.04 per-call pricing and no wallet/API key required. No contradiction with annotations.

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

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

The description is front-loaded with the hook question and the core GO/HOLD/STOP mechanism before any elaboration, and each block — differentiation, policy detail, cost, auth — earns its place. Minor waste: 'Required inputs: address, from, to' duplicates the schema's required array, and the x-credit-token header/free-tier clause is more verbose than necessary.

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 rich annotations and an output schema, the description covers the essentials: purpose, per-parameter roles, liveness, differentiation from siblings, cost, and auth requirements. The remaining gap is action semantics — what an agent should do upon receiving GO vs. HOLD vs. STOP is left implicit rather than stated.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by mapping each parameter to its role in the check: sender policy resolved against 'from', receiver policy against 'to', executor policy against the operator, and 'address' identified as the token. It reinforces the schema's 'transferFrom operator' hint with the reason the executor matters. It does not add new format or constraint 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?

Opens with the question 'Will THIS transfer (from→to) clear right now?' and immediately specifies the deliverable: 'get one GO/HOLD/STOP on whether this exact transfer clears NOW'. It explicitly separates itself from siblings — 'Every other B20 tool is per-token due diligence bought once; this is the check an agent runs on every payment' — and from ERC-20 tools ('No ERC-20 tool can see it').

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?

'This is the check an agent runs on every payment' states the when-to-use condition directly, and 'Every other B20 tool is per-token due diligence bought once' implies when not to use it (one-time due diligence). The pricing and free-tier detail also support cost-aware routing. However, it does not name specific alternative tools (e.g., b20_access_type, b20_gate, pre_trade_gate), leaving the when-not condition at the group level.

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

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

Annotations already mark this as read-only/idempotent, and the description adds value beyond that: unmined blocks return found:false with a reason rather than an error, results are raw chain data with no interpretation, and access details (x402 pricing, x-credit-token header, free tier, no key/wallet) are disclosed. No contradiction with annotations.

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

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

The description is dense and front-loaded, with core behavior first and pricing/auth last. It is longer than minimal, but each sentence carries operational information; only minor redundancy like 'On Base' repeated in the pricing sentence.

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

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

For a single-optional-parameter read-only tool with an output schema, the description covers purpose, accepted inputs, edge cases, data semantics, and access requirements. 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%, and the description enhances it by enumerating the valid tags (latest/finalized/safe/earliest) and specifying the 0x… hash format. It doesn't go into block-number formatting, but the schema plus description is sufficient.

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 the resource precisely — one Base block by number, hash, or tag — and enumerates the returned fields (height, hash, parent, timestamp, gas, base fee). It is clearly distinct from sibling transaction/receipt/status tools, though it never uses an explicit operation verb like 'get' or 'fetch'.

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 concrete usage context: accepted identifiers (block number, 0x hash, latest/finalized/safe/earliest) and the unmined-block edge case returning found:false. It doesn't explicitly say when not to use it or name alternative tools, but the usage conditions are clear enough.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool's safety profile is covered. The description adds valuable context beyond the annotations: it names the Base L2 Resolver as the source, states no API key is needed, and discloses pricing and rate limits ($0.01/call, x-credit-token header, 1 free call/day). No contradiction with annotations.

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

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

The description is front-loaded with purpose and examples, and the auth/pricing details are genuinely useful. Minor redundancy ('No API key required' appears twice) prevents a perfect score.

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

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

With one well-documented parameter, an output schema, and annotations covering the read-only/idempotent behavior, the description supplies all remaining context an agent needs: source resolver, input format, examples, cost, and authentication method. Nothing essential 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 query parameter, so the baseline is 3. The description adds meaning by explaining that the query can be either a Basename or an address and by giving a concrete example of the bidirectional behavior, which goes beyond the schema's bare 'Basename or address'.

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

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

The description opens with a specific verb-resource pair ('Resolve names ↔ addresses on Base') and immediately gives concrete bidirectional examples ('jesse.base.eth into an address, or an address into its primary Basename'). This makes it easy to distinguish from sibling resolution tools like ens_resolve or basename_profile.

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

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

The description gives clear context for when to use the tool: Basename resolution on Base L2, with both forward and reverse directions. It also states required input and access requirements. However, it does not explicitly name alternatives or exclusion conditions, 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, openWorld, idempotent, and non-destructive behavior. The description adds meaningful behavioral context: it reads from Base's L2 Resolver text records, requires no wallet or API key, and describes the x402 pricing model including the prepaid header and free daily allowance. This goes well beyond the structured fields.

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

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

The description is front-loaded with the core purpose and then provides supporting details about data sources, use-case context, input requirements, and pricing. It is longer than strictly necessary, with slight redundancy between 'Full onchain identity' and 'complete Base identity,' but every sentence contributes useful information and there is 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?

For a single-parameter read-only tool with a rich output schema, the description covers everything an agent needs to invoke it correctly: what it returns, where the data comes from, the input format, authentication requirements, pricing, and the use case it serves. Nothing essential 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 `name` parameter is already described as 'Basename or address.' The description reinforces this by saying 'Required input: name' and by elaborating that the tool resolves either a Basename or address, but it does not add substantial format or syntax details beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Resolves') and clearly defines the resource: the complete Base onchain identity behind a Basename or address. It enumerates the resolved fields (avatar, description, website, social handles), which distinguishes it from simpler name-resolution tools like basename or ens_resolve.

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

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

The description provides clear context for when to use it — turning a counterparty address into a real human/entity profile beyond just a name. It also positions the tool relative to address-trust, saying it complements verification with human context, which helps an agent choose between them. It does not explicitly name sibling alternatives, 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 readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds genuinely useful behavior: the nonce count is interpreted differently for wallets vs contracts and both are reported under their own names. It also discloses input requirements and pricing/auth model, going well beyond annotations.

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

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

The description is front-loaded with the core purpose and includes useful operational details like pricing and authentication. Every part contributes to invoking the tool correctly, though the free-call and credit-header details are slightly dense.

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

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

Given the simple one-parameter schema and rich annotations, the description covers input, semantics, use cases, chain, pricing, and auth. The presence of an output schema means return values need not be described. Nothing essential is missing.

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

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

The schema only describes address as 'Address', but the description clarifies it must be a Base address and explains that it can represent either a wallet or a contract. This adds meaning beyond the schema despite 100% 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?

Description clearly identifies the resource (any Base address) and the specific data returned: next nonce, ETH balance, and contract status. It also disambiguates the nonce meaning for wallets versus contracts, which distinguishes it from generic address tools and prevents misinterpretation.

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 explicit use cases: 'before building a transaction' and 'to tell a fresh address from a used one.' It does not name alternative tools or exclusions, but the context is clear enough for an agent to select it appropriately among siblings.

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

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

Annotations already mark the call read-only, idempotent, and non-destructive, and the description adds the state it can return (success/reverted, gas, fee, logs, deployed address) and how the API behaves when no receipt exists. It also discloses pricing and authentication requirements, going well beyond the structured hints.

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

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

The description is front-loaded with a memorable summary and then gives dense but relevant detail on returned fields, edge behavior, and access requirements. It is slightly long because of pricing/header details, but no sentence is 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?

With one required parameter, a full output schema, and rich annotation hints, the description still adds the critical missing-receipt interpretation and contract-deployment behavior. There is no obvious information an agent needs to call it correctly.

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

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

Schema coverage is 100%: the only parameter, hash, is described as 'Transaction hash'. The description merely repeats that hash is required and does not add format or source guidance beyond the schema, so the schema carries the semantic burden.

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

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

The description identifies a specific resource (Base transaction receipt) and the core question it answers: success/reverted, cost, and touched contracts. It is distinct from sibling transaction tools by focusing on the receipt and even covers contract-deployment output, so an agent can tell it apart from base_tx or tx_decode.

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 provided: supply a hash to get execution results, and interpret a missing receipt as pending/dropped/never rather than failure. It does not name an alternative tool like base_tx for when receipt fields are not needed, so it stops short of explicit exclusions/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?

Beyond the readOnly/idempotent/openWorld annotations, the description discloses important behaviors: contract creation is flagged via null to, pending transactions via null block, and unknown hashes return found:false rather than an error. It also explains access/pricing behavior, such as the x-credit-token header and free daily 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?

The description is front-loaded with the core purpose and does not waste words on fluff. It is longer than strictly necessary, but the extra details about special cases, unknown-hash behavior, and access requirements all serve the agent's correct invocation.

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

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

Given a single documented parameter and the presence of an output schema, this description is complete for invocation: it covers the purpose, special-case flags, error/unknown behavior, and how to authenticate/cost. No critical operational detail is missing.

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

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

The schema already fully documents the only parameter (hash) with 100% coverage, so the baseline is 3. The description adds 'Required input: hash' but does not meaningfully extend the parameter's semantic meaning beyond what the schema states.

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

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

The description clearly identifies the tool as returning a raw, unedited Base transaction by hash, listing the specific fields returned. It differentiates from likely siblings such as base_receipt, base_block, tx_decode, and ai_tx_explain by emphasizing 'exactly as the chain has it' and 'unedited.'

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

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

The description makes the use case clear: retrieve a raw transaction by hash when you need the chain-level fields. It does not explicitly name alternatives or state when not to use it, but the raw-transaction framing gives clear context relative to sibling 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?

Anotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, and the description adds genuine behavioral context beyond that: the Beryl upgrade timing (7-day to 5-day window, dual-proof fast path at ~1 day), the event-decoding mechanism, and the cost/auth profile ($0.04/call over x402, prepaid x-credit-token header, 1 free call/day, no wallet or API key). This is material, non-redundant 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?

The description is dense and front-loaded: the first sentence states the core question and rules, then mechanism, audience, input, pricing, and auth follow in order. Each sentence carries distinct information, though the pricing sentence is longer than strictly necessary and could be trimmed without losing meaning.

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

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

With an output schema present, the description needn't explain return values, and it covers purpose, mechanism, temporal rules (Beryl date of 2026-06-25), the single required input, pricing, and authentication prerequisites. The only minor gap is guidance on invalid txs or edge cases, but for a one-param read-only tool this is near-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?

Schema coverage is 100% — the tx parameter is described as 'Base withdrawal-initiation txHash' — so baseline 3 applies. The description echoes 'Required input: tx' and 'Base withdrawal-initiation tx' but adds no format, encoding, or validation detail 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?

The description names a specific verb-resource pair: it 'decodes the L2ToL1MessagePasser event (the withdrawalHash, target & value needed to prove/finalize on L1) and estimates the finalization windows' from a 'Base withdrawal-initiation tx'. This is clearly distinct from siblings like base_tx or tx_decode, and it states the concrete outputs an agent will receive.

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 use case with 'When can a Base→L1 withdrawal be finalized?' and scopes it 'For agents managing cross-chain liquidity', giving implied context for when to call it. However, it never names sibling alternatives (base_tx, base_receipt, tx_decode) or states when NOT to use this tool, leaving the selection logic largely to inference.

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

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

Annotations already establish read-only, non-destructive, idempotent behavior, and the description adds valuable context on top: paid call cost, x402 on Base, credit-header requirement, free daily call, no wallet/API key needed, and riskiest-first sorting. This goes well beyond the annotation coverage and helps an agent understand real-world invocation requirements.

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 mostly tight and front-loaded with the core purpose, and every major piece of invocation context appears. It loses a point for the redundancy between 'Rug-score up to 10 tokens in one call' and 'Screen up to 10 Base tokens in a single paid call', which says nearly the same thing twice.

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

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

With one well-documented parameter, an output schema, and rich annotations, the description needs only to cover invocation specifics, which it does: pricing, credit mechanism, network, authentication, and output ordering. Nothing essential is missing for an agent to select and call this tool correctly.

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

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

Schema coverage for the single 'addresses' parameter is 100%, so the schema already documents the comma-separated format and the 10-token limit. The description only restates that addresses are required and does not add materially new parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific action and resource: 'Rug-score up to 10 tokens in one call,' and clearly states what the output contains. It also distinguishes itself from per-token siblings by emphasizing batching and the absence of per-token cost, making the tool's niche obvious.

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

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

The description explicitly says it is 'Built for agents triaging a watchlist or portfolio without paying per token,' giving clear when-to-use context. It does not name an alternative for single-token scans or state when-not-to-use, but the batching framing effectively communicates the intended scenario.

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 (read-only, idempotent, non-destructive), the description reveals meaningful behavior: it accounts for country-specific weekends (e.g., Friday-Saturday), recognizes national public holidays, names every skipped day, and separates provincial holidays. It also discloses operational requirements such as pricing, prepaid header, and no wallet/API key needed. This is substantial context that aids correct invocation and interpretation of results.

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 dense but well-structured: opening with a memorable hook, then the core operation, country coverage, holiday handling, use cases, required input, and access/pricing details. Every sentence carries useful information and the main functionality is front-loaded. It is slightly longer than strictly necessary due to the pricing details, but those are operationally relevant.

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

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

The description covers the tool's purpose, country/range, holiday nuance, use cases, required input, and access requirements, and an output schema exists for return values. Remaining gaps include explicit constraints on parameter combinations (e.g., add vs to exclusion) and exact date format expectations. Overall, it is nearly complete for a moderately complex 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?

The schema already covers all four parameters; the description supplements it by clarifying the two operating modes: 'add' with a start date, or count between 'from' and 'to'. It reinforces that country is mandatory. However, it still leaves some ambiguity about date formats and whether 'add' and 'to' are mutually exclusive, so the description does not fully resolve all parameter-interaction questions.

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

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

The description clearly identifies the tool's function: add business days to a date or count them between two dates, with country-specific weekend and holiday awareness. This is a specific verb-resource pair that distinguishes it from generic date-calculation tools. It also names the required input (country) and the potential use cases, leaving no ambiguity about what the tool does.

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

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

The description explicitly states the intended use cases ('Built for payment terms, SLAs and delivery dates') and clarifies a subtle decision point: provincial holidays are not treated as national closures and are listed separately so they can be applied when the case is regional. It does not name alternatives, but none of the sibling tools offer similar functionality, and the context is clear enough for an agent to select it. A slightly higher score would require explicit when-not-to-use guidance, which is absent.

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

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

The description discloses important traits: token is shown once, balance lasts 180 days, no wallet/API key needed. Annotations do not cover these details. However, the text contains an internal contradiction: 'each call debits its price from your balance' vs 'send a prepaid x-credit-token header for unlimited calls'. This makes actual metering behavior unclear.

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 over-length and repetitive about x402 pricing, and the final sentence jumbles several ideas: per-call pricing, credit-token usage, and free daily calls. A cleaner front-loaded statement of 'buy prepaid credits → get token → attach header' would be more effective. Some details, like tier bonuses and 180-day expiry, are earned, but the contradictory 'unlimited calls' phrase costs clarity.

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

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

An output schema exists, so return-value details are not needed. The description covers token generation, expiry, tiers, and the no-wallet requirement. It is incomplete regarding edge cases such as insufficient balance or omitted tier, and the contradictory unlimited-calls wording undermines confidence. For a payment-related tool, this is adequate but not fully dependable.

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 simple string tier field. The description enriches this by giving exact accepted values and bonus percentages: $0.25 starter, $1, $5 (+10%), $20 (+20%). It does not explain what happens if tier is omitted (it is not required), but overall it adds useful meaning beyond the schema.

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

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

The description clearly states the tool buys a prepaid balance and returns a secret credit token, which is distinct from the many data/analysis siblings. The main purpose is understandable. However, the later pricing sentence ('Priced $5.00 per call over x402 on Base') muddies whether this tool is for purchasing credits or paying per call.

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

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

It gives a concrete use case: 'Built for agents that fire many checks a minute', and frames prepaid credits against per-request x402 settlement by saying 'no per-call signature, no settlement latency'. It also mentions a free alternative ('1 free call/day per tool'). It does not name specific sibling tools, but the context is clear enough for an agent to select it when buying prepaid balance.

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

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

Annotations already mark it as read-only and idempotent; the description adds meaningful behavioral context: it is a live snapshot, costs $0.01 per call, supports a prepaid x-credit-token header for unlimited calls, offers 1 free call/day, and requires no wallet or API key. No contradiction with annotations.

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