x402 Bazaar

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

No annotations exist, so the description must fully disclose behavior. It includes pricing details (cost, payment mechanism) but fails to state if the tool is read-only, whether it modifies state, or any required permissions. Lack of behavioral context beyond 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 a single sentence, concise and front-loaded with the core purpose. Pricing and payment details are appended in parentheses, keeping it compact but slightly cluttered. Could be split for 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?

For a simple 1-parameter tool with no output schema, the description provides the essential purpose and cost context. However, it lacks details on return format (e.g., boolean, score) and what 'trust' means, leaving some ambiguity.

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 basic description 'Address to check'. The tool description adds meaningful context by explaining what the check determines (trust level, verification status), enhancing parameter semantics beyond the schema.

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

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

The description clearly states the tool's purpose: checking if a counterparty is Coinbase-verified or an anon/sybil. This distinctively differentiates from siblings like address-intel, which likely provides general address 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?

The description implies usage for trust verification but does not explicitly guide when to use this tool over alternatives like address-intel, nor does it mention when not to use it. No when-not or exclusion criteria 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?

No annotations are provided, so the description must disclose all behavioral traits. It mentions cost and the need for a prepaid token, but does not explain rate limits, response format, or whether it requires network access. This is insufficient for full transparency.

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 concise, using a single sentence that front-loads the purpose. The inclusion of pricing info adds some noise but is still efficient. It could be slightly more structured, but it 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?

Given the absence of an output schema, the description fails to specify the return format (e.g., free-text string vs. structured data). It also omits details like synchronous/asynchronous behavior or typical length, leaving the agent with incomplete 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?

The schema description coverage is 100%, so the baseline is 3. The description does not add extra meaning beyond the schema's 'Contract address', as it only restates the parameter without additional context or constraints.

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 it explains contract risks in plain English, specifying the verb 'explain' and the resource 'contract risk'. It distinguishes itself from sibling tools like 'contract-danger' and 'rug-score' by focusing on plain English explanations.

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 mentions the pricing model (prepaid token or free daily call) but does not explicitly state when to use this tool over alternatives. It lacks explicit when-not or exclusions, though the purpose is 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?

With no annotations provided, the description carries the full burden. It only discloses cost and payment mechanism but omits important traits like failure behavior, rate limits, or output structure.

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 a single sentence that efficiently conveys purpose and payment info. However, the payment details could be separated or placed elsewhere for 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?

The description explains purpose and payment but lacks details on return format (just 'structured JSON') and potential edge cases. Given no output schema, more completeness would be beneficial.

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 does not add any meaning beyond the schema; it does not explain 'list' or 'fields' in context.

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 converts unstructured text to structured JSON, which is a specific verb-resource combination. It distinguishes from the sibling ai-extract-batch by implying single-call usage.

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 indicates this is a single-call version ('one call') and explains the payment options, giving context on when to use it. However, it does not explicitly compare to ai-extract-batch or provide 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?

With no annotations, description must cover behavioral traits. It discloses pricing, free call policy, and batch limit but omits auth requirements beyond 'send a prepaid x-credit-token', idempotency, error handling, or return behavior. Insufficient for a paid tool.

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

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

Single sentence is concise but packs pricing details in parentheses, burying core functionality. Front-loaded with purpose but lacks emphasis on extraction behavior. Not overly wordy, but structure could be improved by separating function and cost.

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?

Tool has 3 params, no output schema, and no annotations. Description fails to explain output format or how extracted data is returned. Missing critical context for an agent to invoke correctly (e.g., does it return structured data or raw text?). Incomplete for autonomous use.

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 covers 3 params with basic descriptions. Description adds context that 'fields' apply to all texts uniformly, which is helpful. However, it doesn't specify valid field format or examples, leaving ambiguity. Baseline 3 due to full schema coverage, with minor added value.

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 states 'Same fields across up to 10 texts' indicating batch extraction of consistent fields from multiple documents. Name 'ai-extract-batch' contrasts with likely singleton sibling 'ai-extract'. However, it doesn't explicitly define the extraction action (e.g., 'extract data fields from documents' reduces specificity).

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

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

No explicit guidance on when to use this tool vs alternatives like ai-extract. Description mentions 10-text limit and payment structure but lacks when-to-use, when-not-to-use, or prerequisite information such as needing prepared credit tokens.

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

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

With no annotations, the description covers basic behavior: AI-generated output, paid usage, free limit. However, it lacks details on output format, data sources, or side effects. The description is partially transparent but insufficient for full understanding.

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 a single sentence with a dash and parenthetical, conveying purpose and cost efficiently. It is concise but could be better structured to separate purpose from usage constraints.

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 simplicity (no parameters, no output schema, no annotations), the description provides adequate context: what it does and cost. However, it omits output format and data source, leaving some gaps for a complete understanding.

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 no parameters, so schema coverage is 100%. Per guidelines, baseline is 4. The description adds context by specifying that the brief is about the Base token market, clarifying the scope.

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 it provides a 'Claude-written situational brief of the Base token market,' indicating a specific verb (generate brief) and resource (Base token market). This distinguishes it from sibling tools like ai-token-report or ai-summarize, which serve different functions.

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 use for obtaining a market brief and mentions cost (free call per day, otherwise prepaid token), but does not explicitly contrast with alternatives or state when not to use it. No comparison to sibling tools is provided.

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

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

The description reveals payment behavior ($0.03 cost, prepaid token or free call) and output format (bullet points), but lacks details on rate limits, error handling, or length constraints. With no annotations, this provides moderate behavioral context.

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

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

The description is concise, front-loading the key purpose before payment details. However, the payment info slightly clutters the core message, preventing a top 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?

For a simple one-parameter tool with no output schema, the description covers input, output format, and cost. It could mention size limits or example usage, but is largely 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?

The description does not add meaning beyond the schema's 'Text to summarize' for the single parameter. Since schema coverage is 100%, 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 states the tool converts any text into crisp bullet points, using a specific verb (summarize) and resource (text). It distinguishes from siblings like ai-extract and ai-translate by specifying the output format and action.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., ai-extract for extraction, ai-translate for translation). The description mentions pricing but does not help an agent decide when summarization is appropriate.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool uses Claude to write a verdict, costs $0.12 per call (paid via x-credit-token), and offers one free call per day. This gives agents clear expectations about cost and usage limits.

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

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

The description is a single sentence that packs purpose, chain, cost, and payment method efficiently. While it includes pricing details, these are relevant for agent decision-making. No unnecessary 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 simplicity of the tool (one parameter, no output schema, no annotations), the description adequately covers what the tool does, what it returns (a verdict), the required payment, and the target chain. It misses details about the verdict content, but overall is sufficient.

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

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

The input schema has one parameter (address) with 100% description coverage. The description adds that the token is on Base, but does not elaborate on the parameter format or constraints beyond what the schema provides. Baseline score 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 the tool generates a 'due-diligence verdict' for a Base token, which is a specific verb+resource. It distinguishes from siblings by highlighting that the verdict is 'Claude-written' and focusing on due diligence, unlike many other tools that provide risk scores or basic info.

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 the tool is for Base tokens and requires credits or free calls, but it does not explicitly state when to use this tool over similar ones like token-risk or deep-dd. No when-not-to-use or alternative guidance is provided.

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

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

With no annotations, the description carries the full burden. It discloses cost ($0.03, payment via x-credit-token), a free daily call, and a 6K character limit, providing significant behavioral context. However, it does not mention error handling or rate limits beyond the daily free call.

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

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

The description is a single, well-structured sentence that front-loads the purpose and includes essential details (limits, cost, payment) without any fluff. Every piece of information 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?

For a simple translation tool with no output schema, the description covers purpose, limits, cost, and usage context adequately. It lacks explicit error behavior and output format, but the tool complexity is low, so the description is fairly 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 description adds value by specifying the character limit for the 'text' parameter and clarifying that 'to' accepts any language, which goes beyond the schema's 'Target language' description.

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 'Translate up to 6K chars to any language', providing a specific verb and resource. It distinguishes the tool from siblings, which are primarily blockchain analytics tools, making the 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 implies usage by stating character limit and cost, but does not explicitly specify when to use this tool versus alternatives. No exclusions or context for when not to use are provided, though the lack of similar sibling tools reduces the need for alternative 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?

Discloses pricing ($0.04) and payment methods (x402, prepaid token, free call/day). No annotations provided, so description carries full burden. No contradictions noted.

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?

Single sentence conveys purpose, pricing, and payment methods efficiently. Slightly secondary details (payment) could be separated, but overall concise.

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

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

Complete description for a simple tool with one parameter. Covers purpose, pricing, and access method. No output schema needed for explanation text.

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 covers the single parameter 'hash' with description 'Transaction hash.' The description adds no further semantic details, but schema coverage is 100%, so 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?

Clearly states it provides a 'Plain-English explanation of any Base transaction,' specifying the verb (explain) and resource (Base transaction). Distinguishes from siblings like tx-decode by emphasizing human-readable 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?

Implies usage for understanding transactions in plain English, but no explicit when-to-use, when-not-to-use, or comparison with sibling tools like tx-decode.

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?

No annotations are provided, so the description must fully disclose behavior. It mentions 'drain' and 'revoke' but does not clarify whether the tool performs a read-only audit, initiates a transaction, or requires user authorization. The pricing detail is irrelevant to behavioral transparency.

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 one sentence that conflates purpose with pricing. It is not concise; the pricing information could be in a separate field. The core purpose is not front-loaded effectively.

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 security audit nature and many siblings, the description lacks completeness. No output format, return value, or post-invocation effects are described. Important behavioral context (e.g., whether it's read-only) is missing.

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

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

Schema coverage is 100% for the single parameter 'address'. The description adds no additional meaning beyond what the schema already provides (wallet address). 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 hints at auditing a wallet for draining assets and revoking permissions, but it blends pricing into the purpose statement. It does not clearly state what the tool does (e.g., list, identify, or simulate) and fails to distinguish from siblings like 'spend-audit' or 'approval-advisor'.

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

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

No guidance on when to use this tool versus alternatives. The description includes payment details but omits context like network requirements or prerequisites (e.g., wallet connected to Base). An agent cannot determine the appropriate scenario for invocation.

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

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

With no annotations, the description carries full burden. It discloses cost and payment mechanism, suggesting it's a read-only analysis tool, but does not explicitly state whether it modifies state, what happens if payment fails, or other behavioral traits like rate limits or authentication.

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 concise (one sentence) but mixes functional purpose with pricing in a parenthetical aside. It is front-loaded with the core function, but the structure could be improved by separating pricing into a different field or placing it after a clearer statement.

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

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

Given no output schema and one parameter, the description explains the tool's purpose and cost but lacks details about output format (e.g., what a 'revoke order' looks like) and how it integrates with sibling tools. It is adequate but leaves gaps for an agent to fully understand usage.

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 sole parameter 'address' described as 'Wallet address'. The description does not add any additional meaning beyond the schema, such as format or chain specificity, so 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 states the tool's function: identifying approvals that could drain you and providing a revoke order. It distinguishes from siblings like 'revoke-builder' and 'token-approvals' by combining exposure analysis with revoke ordering, though the verb+resource could be more explicit.

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

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

The description mentions cost and payment method ($0.05, x402 on Base, prepaid credit token or free daily call), implying usage context. However, it does not provide guidance on when to use this tool versus sibling tools like 'revoke-builder' or 'token-approvals', nor does it state prerequisites or exclusions.

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

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

With no annotations, the description partially addresses behavior by disclosing pricing, payment method (x402, x-credit-token), and a free call limit. However, it does not explain what the tool returns or any other side effects, leaving gaps in transparency.

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 a single sentence that combines the tool's title, purpose, pricing, and payment method. It is somewhat cluttered and could be more concise or structured to improve 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?

Given the tool's simplicity (1 param, no output schema), the description is insufficient. It does not explain return values or 'decoded per scope', leaving uncertainty about the tool's output and behavior.

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

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

The input schema has 100% coverage with a single parameter 'address' described as 'B20 token address'. The description does not add any additional meaning beyond the schema, so it meets the baseline but provides no extra value.

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 mentions 'B20 Access Type' and suggests it decodes whether the token is permissioned or blockable, but it is phrased as a question and mixed with pricing details. It does not clearly differentiate from other b20-* tools, leaving ambiguity about its specific function.

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

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

No guidance is provided on when to use this tool versus sibling tools like b20-authenticity or b20-batch. The description only includes payment and rate limit information, which is operational, not contextual for tool 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?

No annotations exist, so description bears full burden. It discloses cost ($0.03), payment method (x402 on Base, or x-credit-token), and free daily limit, which are behavioral traits. However, side effects or required authorization beyond payment are not mentioned.

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

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

Description is a single sentence packing multiple details (content type, price, chain, payment methods, free tier). Reasonably concise but could be more structured; pricing might be better placed elsewhere.

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

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

No output schema, so description should explain return format. It only says 'On-chain issuer notices & corporate actions' without stating structure. Also lacks prerequisites like needing an x-credit-token or willingness to pay.

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 for 'address' is 'B20 Asset token address', which is already clear. Schema coverage is 100%, so baseline is 3. Description adds no further meaning beyond that.

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 indicates the tool retrieves on-chain issuer notices and corporate actions for a B20 token, which is a specific verb+resource. It distinguishes from siblings like b20-info or b20-dossier by focusing on announcements, but pricing details add noise.

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

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

No guidance on when to use this tool versus alternatives like b20-info. The description mentions payment options and a free call per day, which is meta information but does not help the agent decide between 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?

No annotations provided, so description must bear full burden. It discloses cost and free call but does not state read-only nature, return format, or error handling.

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?

Description is concise, front-loaded with purpose. Minor unnecessary detail about payment mechanism could be separate, but overall efficient.

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?

Lacks output schema and does not describe return value or interpretation of results. Incomplete for a tool that determines authenticity.

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

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

Single parameter 'address' already described in schema as 'Token address' (100% coverage). Description adds no extra meaning beyond payment context.

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 the tool checks if a B20 token is real or a lookalike. Uses specific verb 'check' and resource 'B20 Authenticity', distinguishing it from sibling b20-* 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?

Implies usage for verifying B20 authenticity, mentions payment and free call, but no explicit guidance on when to use vs siblings like b20-info or b20-safety.

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

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

No annotations provided. Description lacks clarity on safety profile (read-only vs mutation) and side effects. Adds cost and limit details but not enough behavioral context for an unannotated tool.

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

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

Single sentence with purpose and key constraints (limit, cost). Front-loaded and efficient, though payment details could be separate.

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

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

Covers purpose, limit, cost, but lacks description of output format (e.g., freeze/seize results per address). Adequate for a simple tool but incomplete without output schema.

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

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

Schema coverage 100%. Description clarifies that 'addresses' are comma-separated B20 addresses, adding value beyond the schema's minimal description.

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 states the tool performs a 'freeze/seize scan' for up to 5 B20 tokens, using specific verb ('scan') and resource ('B20 tokens'). It distinguishes from siblings by specifying batch capability and inputs.

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?

Mentions limit of up to 5 tokens and cost/free call, implying batch use case. However, no explicit guidance on when to prefer this over individual tools like b20-freeze-check or b20-seizure-history.

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?

No annotations provided; the description fails to disclose behavioral traits such as whether the tool is read-only, what authorization is needed, or any side effects. The mention of cost and payment is not behavioral.

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

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

The description is a single sentence with a parenthetical cost note. It is concise and front-loaded with the main purpose, though the cost info may be secondary.

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

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

For a one-parameter tool with no output schema, the description does not explain what the tool returns (e.g., a list of addresses or roles). It leaves the agent guessing the output format.

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 parameter address described as 'B20 token address'. The description adds context about the audit purpose but no additional parameter-level details.

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 audits control of a B20 token (mint, seize, freeze, pause). It is specific but does not explicitly differentiate from sibling tools like b20-mint-watch or b20-freeze-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?

No guidance on when to use this tool versus alternatives. No mention of prerequisites or context for use.

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

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

Discloses cost and token type, but with no annotations, the description carries the burden. Missing details on report contents, data sources, or output format, leaving significant behavioral uncertainty.

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

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

One sentence with cost info appended is concise and front-loaded. However, the cost details may be better placed elsewhere, slightly reducing 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?

Given the absence of output schema and annotations, the description does not explain what the dossier contains or how it helps. The agent lacks information to judge its utility, especially with many similar sibling tools.

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

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

Schema coverage is 100% with a clear parameter description. The tool description adds no extra meaning beyond 'B20 token address'; the mention of 'Base-native B20 token' is not directly tied to the parameter.

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

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

The description clearly states it provides a due-diligence dossier (report) for a B20 token on Base, which distinguishes it from most sibling tools that focus on specific aspects. However, it lacks an explicit verb like 'generate' or 'retrieve'.

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

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

No explicit guidance on when to use this tool versus alternatives like b20-access-type or b20-authenticity. The context suggests it's for a comprehensive report, but no differentiation from other b20-* tools.

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

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

No annotations exist, so the description must carry the full burden. It discloses that the tool costs $0.03 and has a free call limit, but does not state whether it is a read-only operation, any side effects, or how the check is performed.

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 one sentence with useful purpose but includes extraneous pricing and payment details that could be separated. It is moderately concise but could be more focused.

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 lacks details about the return value, what 'blocked or seizable' means, prerequisites, or error handling. With no output schema, the agent gets insufficient information to understand the tool's full behavior.

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 describes both parameters fully (token and wallet addresses). The description adds minimal context by specifying 'B20 token address' and 'Your wallet address', but does not provide examples or format hints 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 checks if a wallet is blocked or seizable on a B20 token. The verb 'check' and resources 'wallet' and 'B20 token' are specific. However, the inclusion of pricing details clutters the purpose slightly.

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

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

No guidance is provided on when to use this tool versus the many sibling tools (e.g., b20-access-type, b20-seizure-history). The description mentions payment methods but not 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?

The description mentions cost and payment options ('send a prepaid x-credit-token, or get 1 free call/day'), but no information about side effects, return type, or failure modes. Without annotations, the description should disclose more behavioral traits such as data source or result structure.

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 a single sentence that packs purpose, cost, and payment info efficiently. It could be clearer by reducing jargon, but it is front-loaded and avoids unnecessary text.

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

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

The tool is a specialized audit with no output schema or annotations. The description only mentions the general action without detailing what the audit report contains or how the agent should interpret results. Given the complexity and many sibling tools, this is insufficient for reliable 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 input schema describes the only parameter 'address' as 'B20 token address', which is clear. The description adds little beyond the schema—it assumes the address is the token to audit. With 100% schema coverage, the baseline is 3, and the description does not provide additional parameter-level value.

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

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

The description names the tool 'B20 Genesis Audit' and states it reveals 'what the issuer did in the initCalls bypass window', which clearly identifies the tool's focus on auditing issuer actions in a specific context. Jargon like 'initCalls bypass window' may be ambiguous, but the core purpose is distinct from similar B20 sibling 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?

No guidance on when to use this tool versus other B20 tools like 'b20-authenticity' or 'b20-dossier'. The description does not provide use cases, prerequisites, or exclusions, leaving the agent without context to choose 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?

With no annotations, the description must convey behavioral traits. It discloses the cost ($0.05), payment method (x402 on Base, prepaid credit token, or one free call per day), and the reactive nature (alerts 'the moment' a token turns seizable). However, it does not mention whether the tool is read-only, rate limiting beyond one free call, or what happens if payment fails.

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

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

The description is concise, using a single sentence with parenthetical details. It is front-loaded with the core purpose. Minor lack of structure (e.g., no separate usage section) prevents 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?

Given no annotations and no output schema, the description should fully explain the tool's behavior. It describes input (optional address) and payment, but omits what the alerts contain (e.g., format, severity, or response details). It also lacks guidance on when to choose this tool over similar b20 siblings.

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

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

Schema description coverage is 100%, with the parameter 'address' described as 'B20 token (optional — omit for network feed)'. The tool description adds context about monitoring for seizable tokens, but does not provide additional semantic value beyond what the schema already offers. 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 the tool provides real-time alerts when a B20 token becomes seizable. It uses specific verbs ('alerts') and a specific resource ('B20 token'), distinguishing it from other b20 sibling tools that focus on different aspects like authenticity, freeze-check, or safety.

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 does not provide any guidance on when to use this tool versus its many sibling tools (e.g., b20-freeze-check, b20-safety). There is no mention of alternatives or exclusions, leaving the AI agent without decision support.

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

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

With no annotations, the description adds some behavioral context: the tool costs $0.02, requires a prepaid x-credit-token or offers one free call per day. However, it does not disclose whether the tool is read-only, what happens on failed calls, or any side effects. The cost info is useful but incomplete.

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 main purpose is stated concisely at the start. The pricing and free call info is appended in parentheses, which is slightly distracting but not overly verbose. The description is one sentence and front-loaded with the core function.

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 tool with one parameter and no output schema, the description is adequate. It mentions the token type, cost, and payment method. However, it lacks detail on what the 'full profile' includes (e.g., data fields returned), leaving the agent somewhat uninformed about the output.

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

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

Schema coverage is 100% for the single parameter 'address', with a clear description. The tool description does not add any additional meaning, constraints, or examples beyond the schema, so it meets 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 clearly states it provides a 'Full profile of a Base-native B20 token', which is a specific resource and action. However, it does not explicitly use a verb like 'get' or 'retrieve', and the meaning of 'full profile' is vague. It differentiates from sibling tools by specifying the token type but lacks distinction from other b20 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 implies usage for Base-native B20 tokens but does not provide explicit guidance on when to use this tool versus alternatives like token-info or other b20 tools. There is no mention of when not to use it or specific prerequisites.

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 cost behavior (paid per call, free daily call) and network (Base), which adds value beyond missing annotations. However, it does not clarify if the tool is read-only, triggers transactions, or has 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 a single sentence that front-loads the tool name and primary purpose. It is concise but contains extraneous pricing details that could be separated.

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 explains cost and network but omits return format, output details, and prerequisites. Given the simplicity of the tool, it is partially complete but lacks depth.

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

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

Schema coverage is 100% for the single parameter 'limit' with description 'How many'. The description adds no additional context, so it meets the baseline without improvement.

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 identifies 'Freshly minted B20 tokens on Base', distinguishing it from sibling b20-* tools that focus on other aspects like mint monitoring or info. However, the inclusion of pricing and payment details may distract from the core purpose.

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

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

No guidance is given on when to use this tool versus alternatives like b20-mint-watch or b20-info. The agent has no explicit context for selection based on usage 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?

No annotations are provided, and the description does not disclose behavioral traits such as read/write nature, rate limits, or side effects. The only behavioral hint is a cost mention, which is not standard for behavioral transparency.

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 a single run-on sentence that includes extraneous payment details. It is not succinct and front-loads irrelevant information instead of the tool's core purpose.

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?

Despite having only 3 parameters and 1 required, the description fails to explain what the tool returns or how to interpret results. It mentions 'Payment IDs & compliance tags' but without clarity on output format or structure.

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

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

Schema description coverage is 100% with clear descriptions for each parameter (address, memo, caller). The main description adds no extra meaning, so 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 mixes payment/pricing info with the tool's purpose, making it unclear. The tool likely tracks memos for a B20 token, but this is not clearly stated. The mention of '$0.03, paid over x402 on Base' seems irrelevant to the tool's function.

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

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

No guidance is provided on when to use this tool versus its many siblings (e.g., b20-authenticity, b20-dossier). There is no mention of alternatives or context of use.

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

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

No annotations are provided, so the description must convey behavioral traits. It reveals the tool checks rename capability/history and involves a payment mechanism. However, it does not explicitly state whether the operation is read-only or has side effects, leaving some ambiguity.

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 a single sentence that mixes purpose with pricing. It is front-loaded with the core purpose but could be better structured to separate the what and the cost. No unnecessary words, but lacks clarity due to the blend of information.

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

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

Given no output schema, the description should explain what the tool returns, but it does not mention output format (e.g., boolean, status). It also lacks details on what 'metadata integrity' entails beyond rename questions. The completeness is insufficient for the agent to fully understand the tool's behavior.

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% (one parameter 'address' with description). The description adds no additional meaning or context about the parameter beyond what the schema already provides, so baseline score 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 clearly states the tool checks if a B20 token can rename itself or has been renamed, which is a specific verb+resource. It distinguishes from sibling tools like b20-authenticity or b20-control by focusing on rename integrity.

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 mentions pricing and payment method but does not explicitly state when to use this tool versus alternatives like b20-authenticity or b20-control. No when-not guidance is provided, so usage context is implied but not explicit.

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

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

The description discloses the payment model and rate limit (1 free call/day), which are behavioral traits. However, it does not explicitly state that the tool is read-only or describe output format or error behavior. Given no annotations, this provides moderate transparency.

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 concise, consisting of a single sentence with a parenthetical. It front-loads the core function and includes necessary business model info, though the cost/payment detail could be separated for 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?

The tool is simple with 2 parameters and no output schema, yet the description lacks details about the response format (e.g., list of minters, amounts) and prerequisites (e.g., token address validity, credit balance). This makes it incomplete for an AI agent to fully understand the tool's behavior.

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 describes both parameters (address and days) with 100% coverage. The description adds no additional semantic meaning or constraints beyond what is in the schema, earning the baseline score of 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?

The description clearly states the tool monitors who is minting a specific B20 token in real-time ('Who is printing this token, right now'). It distinguishes from siblings by focusing on minting, which is a specific action among many B20-related 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or comparisons with other B20 tools. The description simply states the function without usage context.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as read-only status, side effects, or authentication requirements. The pricing hints at cost but is 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 a single sentence that conveys purpose and pricing up front. However, the pricing info is somewhat cryptic and could be separated. Overall, it is concise and front-loaded.

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

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

No output schema is provided, and the description does not specify what the tool returns (e.g., a value, status, or comparison result). Given the complexity of a peg check, more detail on output is needed.

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 documented in the schema with description 'B20 stablecoin address'. The description adds no further semantic detail about the parameter, but schema coverage is 100%, so 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 indicates the purpose as comparing the declared currency against the market actual payment, implying a peg check. It distinguishes from siblings like b20-stablecoin by focusing on peg deviation, though the verb is implicit.

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

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

No guidance on when to use this tool versus alternatives like b20-stablecoin or b20-supply. The description includes pricing info but fails to provide selection criteria or context-dependent usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'readiness' and cost but does not explain if the tool is read-only, modifies state, or requires any specific permissions. The payment method is noted but the core operation is not fully transparent.

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 a single sentence with cost in parentheses, which is concise. However, it includes pricing and payment details that are somewhat extraneous to core functionality. It is well-structured but could separate business logic from functional description.

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 no output schema, yet the description does not clarify what 'readiness' returns (e.g., boolean, struct, error). Given the moderate complexity and absence of output details, the description is incomplete for an agent to fully understand the tool's behavior.

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 ('owner' as optional for nonce, 'address' as B20 token address). The tool description adds no further parameter meaning. Baseline 3 is appropriate as schema already provides adequate semantics.

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

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

The description clearly identifies the tool as an inspector for ERC-2612 permit readiness, distinguishing it from other b20-* siblings by specifying 'gasless-approval' and targeting agents. The verb 'Inspector' implies verification, and the resource is well-defined.

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 context (for agents, cost details) but lacks explicit guidance on when to use this tool versus alternatives. No when-not-to-use or exclusion criteria are mentioned. The purpose is clear but usage boundaries are not defined.

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?

No annotations are provided, so the description carries full burden. It reveals the tool is paid and requires a token, but does not disclose whether it is read-only, modifies state, or what happens on invalid input. The behavioral traits are under-specified.

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 a single sentence that front-loads the purpose and appends cost details in parentheses. It is concise with no wasted words, though it could be slightly more structured (e.g., separating purpose from cost).

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-parameter tool with no output schema, the description provides purpose and cost but omits expected output format (e.g., what does 'WHO administers' return?), error handling, or prerequisites beyond payment. Adequate for basic understanding but not 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?

Input schema has 100% coverage (description for 'address' says 'B20 token address'). The description adds no extra meaning beyond the schema, so baseline 3 applies.

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

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

The description clearly states the tool's purpose: 'WHO administers the blocklist that can freeze you?' This is a specific verb-resource combination distinguishing it from siblings like b20-policy-watch, which likely monitors policy changes rather than identifying the administrator.

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 cost and payment method ($0.04, paid over x402 on Base; prepaid token or free call) but lacks explicit guidance on when to use this tool versus alternatives like b20-policy-watch or b20-freeze-check. No when-not or alternative recommendations.

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

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

With no annotations, the description carries full burden. It discloses pricing and payment method, which are behavioral traits. However, it omits idempotency, data freshness, and does not explicitly state read-only nature. Partial coverage.

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 concise with core function front-loaded. Pricing details add length but are relevant for invocation. Could be slightly more streamlined, but effective.

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 lacks clarity on how parameters (policy, address) affect the output. Without output schema, it's unclear what structure is returned. Ambiguity about whether both parameters are needed or for filtering. Incomplete for confident usage.

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. Description adds context (full list) but does not enhance parameter meanings beyond schema descriptions. No additional semantic value for 'policy' or 'address' parameters.

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 returns the full blocklist/allowlist with history, distinguishing it from siblings like b20-policy-watch (monitoring) and b20-policy-admin (management). The verb is implied (retrieve) and the resource is specific.

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

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

Usage context is implied by the name and description (full list retrieval), but no explicit guidance on when to use vs. alternatives or when not to use. Sibling tools exist but no comparison 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?

No annotations are provided, so the description must carry the full burden. It discloses cost and payment options but does not indicate if the tool is read-only, what the response contains, or any side effects. Behavioral traits like mutability or safety are not addressed.

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 concise and front-loaded with the name and purpose. It includes necessary cost and payment details. However, it could be slightly more structured by separating the core check from payment info.

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 1-parameter tool with no output schema, the description adequately covers what the tool does and cost. However, it does not explain the output format or criteria for 'seizable,' leaving some ambiguity for the agent.

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' has a schema description 'B20 token address', which is clear. The tool description adds 'B20' context but does not add significant meaning beyond the schema. With 100% schema coverage, baseline score is 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?

The description clearly states the tool checks if a B20 token became seizable after launch ('Did this token BECOME seizable after launch?'). The purpose is specific and distinguishes from other b20-* tools like b20-safety and b20-seizure-history.

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 mentions cost ($0.03) and payment methods (x402, prepaid credit-token, or free call/day), but does not explicitly state when to use this tool versus alternatives. No direct comparison 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?

No annotations are provided, so the description bears full responsibility. It discloses cost and payment method (x-credit-token, free calls), but does not specify whether the tool is read-only, what side effects exist, or how the freeze/seize check is performed. The behavioral impact beyond input-output is 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 purpose is front-loaded with the question; however, the pricing and payment details consume half the description and could be moved to annotations or a separate field. The description is not excessively long, but fluff reduces conciseness.

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

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

Given no output schema and only one parameter, the description should explain what the tool returns (e.g., list of risky tokens, severity). It does not cover how to interpret results or handle edge cases, leaving the agent without critical usage 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?

The input schema has one parameter 'wallet' with a standard description. Since schema coverage is 100%, baseline is 3. The description does not add any additional parameter 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's purpose: checking which B20 tokens in a wallet can freeze or seize the user. It identifies a specific resource (B20 tokens) and action (risk assessment). However, the inclusion of pricing details detracts slightly from clarity, and the tool's distinction from siblings like b20-freeze-check is implicit.

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

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

No explicit guidance on when to use this tool versus alternatives. Siblings like b20-freeze-check, b20-seizure-history, and wallet-portfolio exist but no comparative advice is given. The description implies usage for checking freeze/seize risks but does not state limitations or prerequisites.

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?

No annotations are present, so the description carries full burden. It discloses the key behavioral trait of being a paid operation requiring credits, with a free daily call limit. It does not mention idempotency or side effects, but for a read-only tracker, the cost disclosure is critical.

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 a single, efficient sentence with a parenthetical cost note. No wasted words, and the key information is front-loaded clearly.

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 tool with one parameter and no output schema, the description fully covers what the tool does and its cost structure. No additional context is needed.

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 parameter 'address' described as 'B20 token address'. The tool description adds context about what the address is used for (rebase multiplier & scaling risk), but this does not significantly add meaning beyond the schema description, leading to a baseline score.

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 states the tool tracks 'Asset-variant rebase multiplier & scaling risk' for B20 tokens. The verb 'track' is implied and the resource is specific. Among many sibling b20-* tools, this one is uniquely focused on rebase multipliers and scaling risk, distinguishing it clearly.

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 mentions payment requirements ('paid over x402 on Base', 'send a prepaid x-credit-token, or get 1 free call/day'), providing context on how to use the tool. However, it does not specify when to use this versus other b20-* tools or provide 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?

No annotations exist, so the description must fully disclose behavior. It mentions 'silent balance rescaling' but does not explain return format, pagination, or side effects. The pricing info is irrelevant to tool 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 description is verbose with irrelevant pricing and credit information ('$0.03, paid over x402 on Base; send a prepaid x-credit-token, or get 1 free call/day'). This detracts from the core purpose and wastes space.

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 simplicity (one parameter, no output schema), the description still lacks completeness. It does not explain what 'rebase history' contains, how results are ordered, or any limitations like historical depth.

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 covers 100% of the parameter with a basic description ('B20 Asset token address'). The tool description adds no further semantic meaning, such as format examples or validation rules. Baseline 3 is appropriate.

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

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

The description states it retrieves rebase history ('Every silent balance rescaling'), but it is cluttered with pricing and credit details. It does not clearly distinguish from sibling tools like b20-rebase or b20-info, leaving ambiguity about when to use this specific tool.

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

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

No guidance is provided on when to use this tool versus alternatives. With many B20 sibling tools, the description should indicate use cases or prerequisites, but it lacks any usage context.

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

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

No annotations provided, and the description does not disclose behavioral traits such as read-only nature, authentication needs, or 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 a single sentence, but it mixes pricing details with functionality, reducing focus. Could be more concise.

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 simplicity of the tool, the description lacks completeness. It does not explain the output format (e.g., yes/no or list) or how to interpret results, despite schema covering parameters.

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 descriptions for both parameters. The description adds no additional meaning 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 clearly states the tool checks if a B20 issuer has ever seized holders, providing a specific verb and resource. However, it lacks differentiation from sibling b20-* 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?

No guidance on when to use this tool versus alternatives. The description includes pricing info but no usage context or exclusions.

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

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

The description discloses the cost ($0.03) and payment method (x-credit-token or 1 free call/day), which is useful behavioral info. However, it does not mention error handling, idempotency, or what happens if the input is invalid, which would be valuable for a mutation-free tool.

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

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

The description is a single sentence, concise and front-loaded with the tool's identity. However, the pricing details could be separated or moved to a more appropriate section, 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 lacks explanation of return values and does not clarify what 'Declared peg currency + issuance & control' means in terms of output. Given no output schema and a simple input, the description should be more explicit. Sibling tools are not differentiated.

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 (100% coverage). The description adds no further meaning to the parameter beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states 'B20 Stablecoin Profile' and mentions 'Declared peg currency + issuance & control', but it does not clearly specify whether the tool retrieves a profile or performs an action. The purpose is ambiguous, and it doesn't distinguish from sibling tools like b20-info 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?

No guidance on when to use this tool versus the many sibling b20-* tools. The description does not indicate prerequisites, alternatives, or conditions for use, leaving the agent to guess.

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

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

With no annotations, the description carries full burden. It discloses that the tool costs $0.04 per call (paid via x402) and offers one free call per day, which is helpful. However, it does not explicitly state that it is a read-only operation, nor does it mention error states or data freshness.

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 a single sentence but combines the core function with billing details in parentheses, making it somewhat cluttered. It front-loads the purpose ('Mint headroom & dilution history') but could be restructured for 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?

For a simple tool with one parameter and no output schema, the description should state what the output looks like. It mentions 'mint headroom' and 'dilution history' but not the format or example values, leaving the agent uninformed about the return data.

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 documented in the schema with 100% coverage. The description does not add additional semantic meaning beyond what the schema provides, so 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 states the tool provides 'Mint headroom & dilution history of a B20', which gives a specific but somewhat vague purpose. The verb is implicit (provides), and the inclusion of pricing details distracts from the core function. It differentiates from siblings by mentioning supply guard, but could be clearer.

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

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

No guidance is given on when to use this tool versus its many siblings (e.g., b20-mint-watch, b20-dossier). There is no mention of prerequisites or alternatives, leaving the agent to guess the appropriate context.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions cost and payment method but is ambiguous about whether the tool actually performs finalization or merely checks status. This lack of clarity on safety and action type is a significant gap.

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

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

The description is a single sentence with a parenthetical cost note, achieving conciseness. It front-loads the purpose, but the cost detail, while useful, could be secondary. Overall efficient.

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?

Without an output schema, the description should clarify the return value or outcome (e.g., boolean, status message). It also fails to resolve whether the tool executes or checks finalization. These omissions make the description incomplete for an agent to predict behavior.

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

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

Schema description coverage is 100% for the single parameter 'tx', which is well-described as 'Base withdrawal-initiation txHash'. The tool description does not add further meaning, 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 clearly identifies the tool as related to Base→L1 withdrawal finalization and asks when it can be finalized. It specifies the resource (Base withdrawal) and implies a verification action, distinguishing it from siblings, though the verb ('Finalizer') is slightly ambiguous.

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 when checking if a Base withdrawal can be finalized, but it does not explicitly state when to use or when not to use the tool, nor does it mention alternatives. Given the absence of sibling withdrawal tools, this is acceptable but not exemplary.

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

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

With no annotations, the description must disclose behavior. It covers cost, payment method, and batch limit (up to 10), but does not mention whether the operation is read-only, idempotent, or any side effects. The nature of a 'risk scan' suggests read-only, but this is not explicitly stated.

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 a single sentence with a parenthetical for details, efficiently conveying purpose, batch size, cost, and payment method. No wasted 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 simple parameter and no output schema, the description covers key aspects: what the tool does, when to use it, and cost. It could mention the output format (e.g., risk scores) for better completeness, but given the tool's simplicity, it is adequate.

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

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

Schema description coverage is 100%, with the parameter 'addresses' described as 'Token addresses (comma-separated, up to 10)'. The tool description adds 'rug-score' context but does not provide additional parameter 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 it performs a batch token risk scan ('Rug-score up to 10 tokens in one call'), with a specific verb ('scan') and resource ('tokens'). It distinguishes from siblings like 'rug-score' (single token) and 'token-risk' by emphasizing the batch capability.

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 the tool: for scanning multiple tokens at once. It also mentions cost and payment method, implying it's not for single-token scans (where 'rug-score' would be used). However, it lacks explicit 'when not to use' or alternative tool recommendations.

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

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

With no annotations, the description carries full burden. It discloses that payment is a one-time $5.00 via x402 on Base, that credits allow calls without per-request settlement, and that free calls are possible. However, it does not specify what happens after purchase (e.g., credit balance, expiration), request/response behavior, or failure modes.

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 a single sentence that packs essential information: pricing, payment method, and usage model. It is efficient but slightly cluttered with parenthetical details. It could be more structured but is not overly long.

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 simplicity (one parameter, no output schema), the description covers the main purpose and key behavior. However, it lacks details on the purchase result (e.g., credit balance update), prerequisites (e.g., account or wallet), and how credits are consumed. An agent might need to infer additional 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?

The single parameter 'tier' is described in the schema as 'Pack: 0.25, 1, 5 or 20 (USD)', which is clear. The tool description adds context by explaining that these are prepaid credit packs and how payment works, enhancing understanding beyond the schema alone. Schema coverage is 100%, so baseline is 3, but the description adds value.

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

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

The description clearly states that this tool allows purchasing prepaid credits for calling, avoiding per-request settlement. The verb 'buy' is implied, and the resource 'credits' is explicit. There is no ambiguity; it distinguishes itself from all other tools which are unrelated.

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 no guidance on when to use this tool versus alternatives. It does not explain scenarios or trade-offs, nor does it mention prerequisites or follow-up steps. An agent would have to infer usage context entirely.

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?

Discloses cost model (free call/day, prepaid tokens) and what the tool returns (block, base fee, etc.). Since there are no annotations, the description carries the burden of behavioral disclosure and does so adequately, though it doesn't explicitly state it's read-only.

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?

Single sentence that packs key information, but includes pricing details that might distract from core purpose. Still efficient and front-loaded.

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?

Describes return values despite no output schema, and covers cost model. Could mention prerequisites or error cases, but for a simple status tool it is fairly 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?

No parameters exist, so the description does not need to add parameter meaning. Baseline score of 4 for zero-parameter tools 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?

Clearly states it provides Base Chain status including block, base fee, ETH price, and transfer cost. The verb 'Status' and specific resources differentiate it from sibling 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?

No explicit guidance on when to use this tool vs alternatives. The description only implies usage by describing the output, but does not say when not to use or mention 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?

With no annotations, the description must fully disclose behavior. It mentions cost and payment but does not state whether the operation is read-only, what the verdict format is, or any side effects. This is insufficient for a check tool.

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

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

The description is short but includes non-essential pricing details that could be separated. It is front-loaded with the purpose, but the pricing distracts from the tool's function.

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 lack of output schema and annotations, the description should explain what the verdict looks like or how results are interpreted. The current text only hints at inputs and cost, leaving the agent underinformed.

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

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

Schema coverage is 100% for the single 'address' parameter, so the description adds no extra meaning beyond the schema. The baseline of 3 applies.

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

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

The description clearly states it performs a compliance check combining OFAC, profile, and risk into a single verdict. This distinguishes it from sibling tools like 'sanctions' which may only cover OFAC. The verb 'check' and resource 'compliance' are specific.

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

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

No guidance is provided on when to use this tool versus alternatives like 'sanctions' or 'address-trust'. The description focuses on pricing but omits usage context.

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

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

No annotations are provided, so the description carries full burden. It discloses pricing and payment method but omits behavioral traits like response format, error handling for unverified contracts, or side effects. Only pricing is mentioned, leaving significant gaps.

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 a single sentence with embedded pricing info, making it concise but somewhat dense. It efficiently conveys purpose and cost without wasted words, though structure could be improved for 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 simple lookup with one parameter and no output schema, the description fails to explain return values (e.g., the ABI text, verification status) or error cases. This lack of output context makes it incomplete for an agent to understand what the tool provides.

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 has 100% coverage for the single 'address' parameter. The description adds chain-specific context ('Base contract'), going beyond the schema's generic 'Contract address' description, thus adding meaningful semantic value.

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: 'Contract ABI Lookup' and asks 'Is this Base contract verified? Get its ABI', specifying the verb (lookup/get), resource (ABI), and chain (Base). It distinguishes from siblings as no other sibling tool explicitly retrieves ABI.

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 for retrieving ABI of a Base contract but provides no explicit guidance on when to use this tool vs alternatives among the many sibling contract tools. It includes pricing and access info rather than usage context.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It hints at owner risk scanning but omits details about what the tool actually does (e.g., checks contract methods, return format, destruction potential, or rate limits). The pricing note is not behavioral.

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

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

The description is brief but includes incidental pricing information (cost, payment method) that may not be essential for tool selection. It is not front-loaded with core purpose; the key function is stated, but extraneous details reduce efficiency.

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

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

Given one parameter, no output schema, and no annotations, the description should explain what results to expect. It does not mention return values or behavior, leaving the agent underinformed about the tool's output and practical use.

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 clear description for the single 'address' parameter. The description adds no extra semantic value beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool is for scanning a contract to see what the owner can do, which is a specific verb+resource. It distinguishes from siblings like 'rug-score' or 'safety' by focusing on owner capabilities, though it does not make this differentiation explicit.

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

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

No guidance is provided on when to use this tool versus sibling tools. There is no mention of contexts, exclusions, or prerequisites, leaving the agent without decision support.

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?

No annotations are provided, so the description must convey behavioral traits. It mentions a one-call cost and payment method, but does not disclose what the report contains, authentication requirements, or side effects. Significant gaps remain.

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 a single sentence that efficiently conveys purpose, chain, and pricing. It is well-structured but could benefit from minor clarification.

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

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

No output schema exists, yet the description fails to explain what the 'full report' contains. Missing details on response format, data fields, or error handling make it incomplete for an AI agent.

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

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

Schema description coverage is 100%, with 'address' and 'size' described adequately. The description adds no extra meaning beyond the schema, so 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?

Description clearly states it provides a 'full report on a Base token' with deep due-diligence, indicating a comprehensive analysis. However, it does not explicitly differentiate from sibling tools like 'ai-token-report' or 'token-risk' which may offer similar reports.

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 when an institutional-grade report is needed, and mentions cost and free call limit, but does not explicitly state when to use vs alternatives or provide 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?

No annotations provided, so description carries full burden. It discloses cost and payment mechanism ($0.04, paid over x402, prepaid credit or free call/day), which is helpful. However, it does not describe return format or data sources.

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?

Description is a single sentence that front-loads the main purpose. It includes cost details parenthetically, which could be separate, but remains concise and readable.

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 no output schema and a single parameter, the description does not explain what the tool returns (e.g., a score, address, risk level), limiting completeness for an AI agent deciding 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?

Input schema has one parameter (address) fully described ('Token contract address'). Description adds no extra meaning beyond schema. Schema coverage is 100%, so baseline 3 applies.

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

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

The description clearly states the tool evaluates deployer reputation, asking 'Who created this token — and can you trust them?' It identifies the resource (token deployer) and the action (assess trustworthiness), distinguishing it from sibling tools like token-info or token-risk.

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

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

No explicit guidance on when to use this tool versus alternatives. Among siblings are many trust/safety tools (e.g., address-trust, token-risk, rug-score), but the description does not specify scenarios for deployer-rep over those.

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

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

With no annotations, the description discloses key behavioral info: cost ($0.02), payment method (x402 on Base), and free call/day allowance. This is valuable beyond the read-only 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?

Single sentence packs purpose, pricing, and payment options with no wasted 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?

No output schema means description should hint at return format, but it does not. However, the purpose is simple, and parameters are clear. Some gap for an agent to understand output structure.

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

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

Schema covers both parameters with descriptions (100% coverage), so baseline is 3. The description reinforces the date parameter but adds no new semantic 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 clearly states it provides the historical USD price of a Base token on a given date, with the term 'Historical' and the date parameter distinguishing it from sibling tools like 'token-price' which likely provide current prices.

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 use for historical dates via the 'Historical' label and date parameter, but does not explicitly exclude current price queries or compare to 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?

No annotations are provided, so the description must carry full burden. It mentions payment details but lacks disclosure of behavioral traits like read-only nature, rate limits beyond the free call, authentication requirements, or response characteristics.

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 a single sentence containing essential information: what the tool does and cost. It is relatively concise and front-loaded.

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 parameter and no output schema or annotations, the description covers purpose and pricing but lacks details on return format, pagination, prerequisites, and differentiation from many sibling tools.

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

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

Schema coverage is 100% with one parameter described as 'Token contract address'. The description adds context about the output but does not enhance parameter semantics beyond the schema.

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

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

The description clearly states it provides 'Token Holder Distribution' with specific data: top holders, concentration, and LP lock. This distinguishes it from siblings like 'holder-forensics' and 'token-info'.

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 includes pricing and payment method, hinting at usage cost, but does not explicitly state when to use this tool over alternatives or provide when-not conditions.

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?

No annotations are provided, so the description carries the full burden. It discloses cost and payment method but does not state behavioral traits such as whether the tool is read-only, destructive, or has any side effects. The lack of any safety or behavioral disclosure leaves the agent with incomplete information.

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 a single sentence that efficiently conveys the tool's purpose and cost/payment details. It is front-loaded and contains no unnecessary words or fluff.

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 has one parameter and no output schema, the description adequately explains what the tool returns (locked status, amount, time) and mentions cost and chain (Base). It would benefit from specifying the output format or any prerequisites, but it is still fairly complete for a simple 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 input schema has one parameter 'address' with description 'Token contract address', and schema description coverage is 100%. The tool description adds context about what the address is used for (checking LP lock details) but does not provide additional semantics beyond what the schema already conveys. 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 states the tool provides LP Lock details: whether liquidity is locked, how much, and until when. It uses a specific verb ('Details') and resource ('LP Lock'), and distinguishes from sibling tools by focusing on liquidity lock status, which is a distinct function among many token-related 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 mentions cost and payment options, which are usage guidelines, but it does not explicitly state when to use this tool versus alternatives like 'token-info' or 'token-risk'. There is no comparison or exclusion criteria, so the guidance is implied but not comprehensive.

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?

No annotations provided, so the description carries full burden. It mentions cost and scope (Base chain) but lacks details on output format, data returned, or any limitations beyond the free tier.

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

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

The description is concise, with one sentence and pricing details in parentheses. It is front-loaded with the main purpose. Slightly verbose with the cost breakdown, but acceptable.

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 no parameters or output schema, the description is the sole source. It explains what and where, but not how results are presented or any filtering. Adequate but could be more informative.

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?

No parameters in the schema, so the description does not need to add parameter info. According to guidelines, 0 params baseline is 4. The description does not mislead.

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 as a scanner for freshly listed/profiled tokens on Base. This distinguishes it from sibling tools like 'trending-tokens' or 'token-info', which focus on different aspects.

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 the tool is for discovering new tokens on Base with a paid model (one free call/day). It does not explicitly state when to use alternatives, but the context is clear. Missing guidance on 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?

No annotations are present, so the description should disclose key behaviors. It mentions cost and payment method but does not state that it is a read-only operation, error handling, or rate limits beyond one free call per day.

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 one sentence long with a parenthetical pricing note. It is relatively concise, though the pricing details could be considered extraneous for purpose clarity. No structural issues.

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

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

With no output schema, the description should hint at return format (e.g., currency, data type). It only says 'Live floor price', omitting important context like the unit of price or possible error responses.

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

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

Schema coverage is 100% with a single parameter 'contract' described as 'Collection contract address'. The description adds no extra meaning beyond that, so 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 'NFT Floor Price — Live floor price for a Base NFT collection', which is a specific verb (get) and resource (floor price). However, it fails to distinguish from sibling tools like 'token-price' or 'multi-price'.

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

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

No indication of when to use this tool over alternatives. Sibling tools exist for similar price queries, but no exclusions or comparisons 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?

No annotations provided, so the description bears full responsibility for behavioral disclosure. It mentions a pay-per-call model but does not describe safety, side effects, or required authentication. The cryptic phrase 'paid over x402 on Base' lacks clarity.

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 short but includes non-essential pricing details that could be omitted or clarified. The core purpose is stated, but the structure could be cleaner.

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?

Missing details: no output schema, no explanation of the scan's behavior, return format, or interpretation of 'hurt you'. With many sibling tools, more context is needed for correct agent invocation.

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

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

Schema description coverage is 100% (one parameter 'address' with description 'Wallet address'). The tool description does not add beyond the schema, but the high coverage baseline makes 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 clearly states a specific verb ('Audit a whole wallet') and resource ('portfolio risk scan'), and distinguishes from siblings like wallet-summary or wallet-portfolio by focusing on risk ('which holdings could hurt you').

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

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

No guidance on when to use this tool vs alternatives among the many wallet and risk tools. Mentions pricing but not contextual usage. Does not state prerequisites or when not to use.

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

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

The description discloses a payment requirement ($0.04, x-credit-token, free call/day), which is a behavioral trait not in annotations (none provided). However, it does not state whether the tool is read-only or has side effects, nor what happens on failed payment.

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

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

The description is relatively short but includes payment details that could be separated. It lacks clear front-loading of the main purpose, instead mixing cost info with the core question.

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

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

With no output schema and no annotations, the description should cover interpretation of results, prerequisites, and limitations. It only mentions cost and a vague question, leaving the user uncertain about what the tool actually returns.

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 describes all three parameters. The description adds no additional meaning to parameters, providing no improvement over the schema.

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

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

The description states 'Position Health Check' and asks 'should you stay in?', implying evaluation of holding a token. However, it lacks a clear verb+resource structure and does not distinguish from sibling tools like token-risk or token-info.

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

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

No explicit guidance on when to use or avoid this tool. The description implies usage when holding a token, but no alternatives or exclusions are mentioned.

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?

No annotations provided, so description carries full burden. It discloses payment model, usage limits, and webhook vs polling options. However, it does not detail error handling, webhook payload, or alert lifecycle.

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?

Single sentence packs purpose, network, payment, and usage modes without wasted words. Front-loaded with tool function.

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 5 parameters and no output schema, description covers core purpose and payment but lacks details on return data (polling response, webhook payload) and error conditions. Adequate but not comprehensive.

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%, baseline 3. Description adds meaning for 'check' (polling alert ID) and 'webhook' (optional). For other parameters, description does not add beyond schema descriptions.

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

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

Description states 'Token Price Alert — Webhook when a Base token crosses your target', which is a specific verb (alert) and resource (price crossing on Base). It clearly distinguishes from sibling tools like 'token-price' which likely return current price rather than webhook notifications.

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?

Description provides context on payment (paid over x402, prepaid credit token, free call/day) and mentions polling alternative. It implies when to use (need alerts) but lacks explicit exclusions or comparison to other 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It only discloses pricing and access requirements, but not what the tool does internally (e.g., reads blockchain state, no side effects). The return format or behavior is not described.

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

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

The description is a single sentence that is relatively concise. However, it includes pricing information that may not be essential for understanding tool usage, slightly reducing efficiency. Still, it is well-structured and front-loaded.

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 simplicity of the tool (1 parameter, no output schema, no annotations), the description covers purpose and access but lacks details on the response type or behavior. It is adequate but incomplete for an agent to fully anticipate outcomes.

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 basic description for the single 'address' parameter. The tool description adds no additional meaning or context about the parameter (e.g., required format, network constraints). The schema already provides minimal but sufficient info.

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 'Proxy / Upgrade Detector' and asks 'Can this contract be changed under you?', which unambiguously indicates the tool's purpose: to detect if a contract is upgradeable or a proxy. This distinguishes it from many sibling tools that focus on other contract aspects.

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 does not provide any guidance on when to use this tool versus alternatives. It only mentions pricing and payment methods, not usage context or exclusions. Given numerous sibling tools, an explicit usage hint is missing.

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?

No annotations provided; the description focuses on pricing and alert trigger but omits behavioral details like monitoring mechanics, polling vs webhook, duration, or 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 a single sentence that front-loads the core purpose, but the embedded pricing details could be secondary. Still, it is concise and efficient.

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

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

With 4 parameters and no output schema or annotations, the description fails to explain how monitoring works (poll vs webhook), how to check status, or what results look like.

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?

All parameters are fully described in the input schema (100% coverage), and the description adds no parameter-specific 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 identifies the tool as a 'Rug Early-Warning Monitor' that alerts when liquidity is pulled, distinguishing it from static analysis tools. However, it does not explicitly differentiate from sibling tools like 'rug-score' or 'exit-liquidity'.

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

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

Provides cost/credit information ($0.10, prepaid token, free call) but lacks guidance on when to use this tool versus alternative rug-related tools such as 'rug-score' or 'lp-lock'.

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?

No annotations exist, so the description must disclose behavior. It mentions the cost and payment method, but fails to describe the output format, any side effects, or error conditions. The free call/day hint is useful but overall transparency is minimal.

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 a single, well-structured sentence that front-loads the purpose and includes essential cost/payment details. No unnecessary words; every part 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?

The tool has no output schema, so the description should explain the return value. It implies a yes/no answer but does not specify the response format. Payment and free call details are good, but missing output specification reduces completeness for a simple 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 the parameter 'address' described as 'Address to screen'. The description adds 'Is this address OFAC-sanctioned?' which reinforces the purpose but does not add significant new meaning beyond the schema. Baseline 3 applies.

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

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

The description clearly states the tool checks if an address is OFAC-sanctioned. The verb 'check' and resource 'address' are specific. Among siblings, 'sanctions-batch' implies this is for single address checks, distinguishing it effectively.

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 for single address sanctions checks, and the sibling 'sanctions-batch' suggests an alternative for batch checks, but no explicit when-to-use or when-not-to-use guidance is provided.

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

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

Discloses key behavioral traits: batch limit (25), cost, and payment/subsidy options. No annotations provided, so description carries full burden; it adequately covers cost and limit.

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?

Single sentence packed with essential info: function, limit, cost, payment methods. Extremely concise and front-loaded, no waste.

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

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

For a simple tool with 1 parameter and no output schema, description covers initiation details (cost, limit, payment) adequately. Could mention result type but not critical.

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 already describes 'addresses' as comma-separated. Description adds meaningful context: batch limit and cost, which are valuable for agent decision beyond 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?

Clearly states 'Batch Sanctions Screening' with specific details: up to 25 addresses against OFAC. Distinguishes from single-address sibling 'sanctions' by including batch size and cost.

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

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

Provides usage context: cost ($0.03), payment method (x402, prepaid token, or 1 free call/day). No explicit when-to-use vs alternatives, but batch nature implies use for multiple addresses.

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

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

With no annotations, the description carries the burden. It discloses pricing and authentication needs but does not describe output format or behavioral traits like destructiveness. It is adequate but lacks depth.

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 a single concise sentence that front-loads the purpose and includes essential usage info (cost, free trial). No wasted 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?

For a simple check tool with two parameters and no output schema, the description is adequate. It explains the core function and cost, but lacks details on return values or what 'sellability' means precisely.

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 adds no additional meaning beyond the schema's parameter descriptions. Baseline score 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 clearly states the tool checks if a token can be sold (honeypot check). It uses a specific verb-resource combination ('Sellability Check') and distinguishes from siblings like 'token-risk' or 'rug-score' by focusing on sellability.

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 mentions cost and authentication (prepaid token or free trial) but does not provide explicit guidance on when to use this tool versus alternatives. Usage context is implied but not detailed.

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?

No annotations are provided, so the description must disclose behavioral traits. It mentions a payment mechanism ($0.03, x402 on Base) but does not state whether the tool is read-only or has side effects. The impact on state (if any) is 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 a single sentence but includes extraneous pricing and credit call details that could be moved elsewhere. It is not overly long but could be more focused on the tool's purpose.

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 complexity of combining swap route and safety analysis, and lack of output schema or annotations, the description is insufficient. It does not explain what information the route includes, how safety is measured, or what the return format looks like.

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%, providing basic param descriptions. The tool description adds no further semantic meaning about 'tokenOut' or 'amountUsd' beyond what the schema states, so 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 hints at providing a swap route and safety assessment ('Where to trade it, the impact, and whether it's safe to receive'), but the core action is ambiguous. The pricing details distract from the core function. It distinguishes somewhat from siblings like token-info or token-risk but lacks a clear verb phrase.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The description does not differentiate this tool from the many sibling tools that also analyze tokens or swaps, leaving the agent to infer usage context.

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