Oblique Markets

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 the cost ($1.00/call), the specific checks performed, and the nature of the output (weighted score with recommendations). This goes beyond a vague 'audits a domain' and gives concrete behavioral expectations.

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

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

Two sentences deliver all essential information: purpose, scope, method, output, and cost. No filler or redundancy; each clause 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 single-parameter tool with no output schema, the description adequately covers what the tool does, what it returns, and key constraints (cost, domain normalization). It lacks examples or edge-case guidance but is otherwise complete for its complexity.

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 'domain', and the schema already describes it as a bare domain or URL normalized to https. The tool description adds no further parameter-specific detail, but the schema is sufficient.

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

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

The description clearly states the tool audits a domain for agent-economy readiness, naming the six discovery surfaces and the output (weighted 0-100 score). It clearly distinguishes itself from sibling tools like x402_endpoint_verify by focusing on a holistic domain audit rather than a single endpoint.

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

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

Gives explicit context: 'Audit any domain for agent-economy readiness' and explains what it checks (six surfaces). It doesn't explicitly name alternatives or when not to use, but the scope is clearly defined and the intended use case is obvious.

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 the full burden. It discloses key behaviors: it performs web research, returns an answer with citations, and costs $0.65/call. However, it does not mention any limitations, failure modes, or whether it is read-only (though this is inferable). The cost disclosure is a positive, but the description could be more transparent about behavior such as source 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?

The description is one sentence, front-loaded with the action ('Answer a question...'), and includes the output ('concise answer with its cited sources') and cost information. It is concise 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?

For a tool with one parameter and no output schema, the description is sufficiently complete: it explains the input (question), the process (current web research), and the output (answer with citations), plus the cost. It doesn't cover edge cases but this is a simple tool, so it's 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?

The input schema already fully describes the 'question' parameter with 100% coverage. The description does not add any additional parameter-level meaning beyond the schema's 'Question to answer with citations.' Thus it meets the baseline but adds 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 clearly states the tool's purpose: to answer a question using current web research and return a concise answer with cited sources. This distinguishes it from sibling tools like web_extract, which extracts raw web content, by focusing on synthesis with citations.

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

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

The description implies when to use the tool—when a question needs an answer backed by current web research—but it does not explicitly specify when not to use it or compare it to alternatives. For example, it doesn't mention web_extract as an alternative for raw extraction. This is implied usage rather than explicit 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?

No annotations are present, so the description carries full burden. It discloses live fetching, automatic RPC failover, and cost per call via x402, going beyond a mere label. No contradictory signals exist.

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, dense sentence packs protocol, network, behavior, use cases, and pricing with no filler. Front-loaded 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?

For a parameterless read-only block-height tool, the description covers input, behavior, cost, and suggested usage. No output schema is present, but the return value (current block height) is implied sufficiently by the description.

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

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

The tool takes zero parameters, so schema coverage is trivially 100%. The description adds useful context about what the value represents and how it is obtained, but no parameter documentation is required.

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

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

States it returns the current Base mainnet block height for eip155:8453, with a clear verb implied ('fetched'). This distinguishes it from sibling tools like base_gas_price or base_tx_status which target different chain data.

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

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

Explicitly identifies use cases as a chain-liveness anchor or confirmation baseline. It doesn't name alternatives or exclusions, but the context is clear from the sibling list and the description's scoped purpose.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavior: it returns gas price components, units, block height, and the cost per call ($0.002/call via x402). This is transparent and goes beyond bare functionality.

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 all essential information: data source, return format, and cost. No unnecessary words or redundancy; every phrase 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 tool's simplicity (zero parameters, no output schema), the description fully covers what it does, what it returns, and additional context (cost). It is complete for an AI agent to select and invoke confidently.

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

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

The tool has zero parameters, and the baseline for such cases is 4. The description adds context about returns (wei/gwei, block height) beyond parameter semantics, which is helpful despite no parameters existing.

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 live Base mainnet gas pricing, specifically eth_gasPrice and baseFeePerGas, with return units (wei/gwei) and block height. This is a specific verb+resource+scope, and no sibling tool covers gas price, so it distinguishes itself.

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

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

The description clearly implies when to use this tool (when needing gas pricing on Base mainnet), but it does not explicitly discuss alternatives or exclusions. Since there is no direct sibling competing with this function, the context is sufficient.

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 goes beyond a simple 'look up' by listing the exact output fields and the pricing ($0.003/call via x402), which is important behavioral context for cost-sensitive agents. It implies a read-only operation and does not contradict any annotations. It doesn't cover error scenarios, but for a simple read tool this is acceptable.

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 leads with the primary action and then efficiently lists the return fields and cost. Every phrase earns its place with zero 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?

For a simple single-parameter read-only tool, the description covers the purpose, return fields, and cost. It doesn't explain error handling or format details, but given the simple schema and no output schema, this is quite complete. It could optionally mention 'returns' explicitly, but the implied return is clear.

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 'hash' parameter, including a pattern and description. The description itself adds no new parameter semantics, but the baseline of 3 is appropriate as the schema already fully documents 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 the tool's function with a specific verb ('Look up') and resource ('Base mainnet transaction'), and enumerates the specific data returned (mined status, success, block number, confirmation count, gas used, effective gas price). This distinguishes it from sibling tools like base_block_number or base_gas_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?

The description makes it obvious when to use this tool: to check transaction status by hash. It doesn't explicitly mention alternatives or exclusions, but the context is clear enough for an agent to select it appropriately. There is no competing transaction-status sibling, so this is sufficient.

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 transparency burden. It discloses that the tool performs a read-only balance check, returns both atomic and formatted values, and incurs a cost ($0.003/call via x402). This adds meaningful behavioral context beyond the input schema, though it omits potential error cases or rate 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 exceptionally concise, with two sentences that front-load the purpose and then add return format and cost details. No wasted words; every sentence earns its place.

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

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

For a simple 1-parameter tool, the description is quite complete: it explains return formats, the underlying contract call, and cost, compensating for the lack of an output schema. However, it does not mention failure scenarios or error handling, which could be relevant for an agent invoking the tool.

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

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

Schema coverage is 100%, so the parameter (address) is fully described in the schema. The description adds the network context ('Base mainnet address') but does not provide additional syntax or format details beyond what the schema already specifies. 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 function: retrieving the live USDC balance of a Base mainnet address. It specifies the exact resource (canonical Base USDC contract) and the verb (balanceOf), distinguishing it from sibling tools like base_usdc_transfer_check.

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

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

The context of use is clear (getting a USDC balance on Base), but there is no explicit guidance on when to use this tool versus alternatives like base_usdc_transfer_check or wallet_analyze. No exclusions or alternative mentions are provided, so usage is implied rather than 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?

With no annotations, the description carries the full burden. It discloses the internal behavior: 'decodes every USDC Transfer log in the receipt (from, to, amount)' and the binary outcome 'settled true/false'. It also transparently states the cost ($0.004/call). Missing edge cases like what happens for non-USDC or non-existent transactions, but the provided detail is above average.

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 core purpose ('Verify a Base mainnet tx hash'), then elaborates with mechanism, use case, and cost. Every phrase earns its place; no filler or redundancy.

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

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

For a one-parameter tool with no output schema, the description is complete: it explains what the tool checks, how it checks it, what it returns (true/false), when to use it, and the cost. The sibling context shows it's well-positioned among related tools, and the description fully satisfies the need.

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

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

The schema already fully describes the single 'tx' parameter with pattern and description, giving 100% coverage. The description adds valuable semantic context by specifying this is a 'Base mainnet tx hash' and that it's specifically for USDC, which is not in the schema. This elevates it above 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 the tool's specific verb and resource: 'Verify a Base mainnet tx hash actually moved USDC'. It goes further by explaining it decodes every USDC Transfer log and answers settled true/false, which sharply distinguishes it from sibling tools like base_tx_status or base_usdc_balance.

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

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

The description provides clear context: 'the check an x402 seller runs before trusting a payment reference'. This tells the agent exactly when to use it. However, it doesn't explicitly mention alternatives or when not to use it, such as when a simpler tx status check would suffice.

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

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

With no annotations, the description carries the full burden and does disclose important behavioral traits: it is a pre-paid operation ($0.02/call via x402), idempotent via a receipt, and limited to 10 jobs. However, it does not describe failure semantics, partial job failures, return format, or authentication requirements, leaving gaps for a paid operation.

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 two sentences, front-loaded with the core purpose, and includes only essential details (cost, idempotency, batch limit). There is no fluff or repetition of schema field names.

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

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

For a paid batch operation with no output schema, the description covers the core function and payment but lacks details about what the returned receipt/batch looks like, error handling, or retry behavior. It is adequate for basic selection but not fully complete for safe invocation.

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

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

The schema has 0% description coverage, so the description must compensate. It adds meaning by explaining that 'jobs' are URL-to-JSON extractions and limits them to 10. It does not explicitly explain 'idempotency_key' beyond the word 'idempotent,' which is a partial gap. Still, the description provides more than the schema alone.

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 action: 'Run up to 10 bounded HTTPS URL-to-JSON extraction jobs.' It specifies the resource (URL-to-JSON extraction), batch limit, and adds unique traits (prepaid, idempotent receipt, cost) that distinguish it from siblings like web_extract or fetch_x402_content.

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 batch extraction of up to 10 URLs and mentions a cost, offering some context. However, it does not explicitly state when to use this tool vs alternatives, nor when not to use it. The batch size and payment model serve as implicit guidance but no clear exclusions or alternatives are named.

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

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

Despite having no annotations, the description discloses the exact output contents (categories, counts, calls, payers, share) and the cost ($0.003/call). It does not explicitly confirm a read-only operation, but the 'snapshot' wording suggests a non-mutating query, which is reasonable.

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, then lists the key data points and cost. Every word adds value, and the dash structure makes it easy to parse quickly.

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

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

With no output schema and no annotations, the description still conveys the essential return value: a classification of the catalogue into categories with multiple metrics. It also includes pricing, making it sufficiently complete for an agent to decide when to invoke it.

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

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

The tool has zero parameters, so the description correctly implies no inputs are needed. This baseline of 4 is appropriate since the schema is empty and there is nothing to explain.

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 explicitly states the tool provides a snapshot of the latest x402 Bazaar catalogue classified into 9 service categories with specific metrics (listing count, settled 30d calls, unique payers, share). This clearly distinguishes it from other bazaar tools that focus on different aspects, such as new listings or pulse.

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

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

The phrase 'Where the x402 Bazaar demand actually is' implies this tool is for understanding demand distribution by category. It gives a clear context for use, though it does not explicitly name alternatives or state when not to use it, which would elevate it to a 5.

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

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

With no annotations, the description carries the full burden. It discloses the diffing behavior, the types of changes reported, and the cost ($0.004/call via x402), which is valuable context. It doesn't cover edge cases like snapshot availability or output format, but for a zero-parameter tool, the core behavior is 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 entire description is one well-structured sentence that front-loads the purpose and appends cost information. Every word adds value, with no filler or redundant phrasing.

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 what the tool does, its scope, and its cost. Given the lack of output schema and annotations, it is reasonably complete for a simple, parameterless diff tool. It could mention output format or snapshot dates, but the core use case is clear.

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 is empty (0 parameters), and the description appropriately focuses on output/behavior rather than parameter syntax. The baseline score of 4 applies because no parameter explanation is needed.

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 diffs the two latest daily snapshots of the x402 Bazaar catalogue, reporting added, delisted, and price-changed resources with before/after amounts. This specific verb+resource+scope distinguishes it from sibling bazaar tools like bazaar_new_listings or bazaar_price_stats.

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 tracking overnight changes but does not explicitly state when to use this tool versus alternatives like bazaar_market_report or bazaar_trending. No exclusions or 'use instead' guidance are provided, leaving the comparison implicit.

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

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

With no annotations provided, the description carries the full burden. It discloses the tool's behavior: performs a live probe of the resource, evaluates specific criteria (valid 402, description, output schema, category, price floor), reviews day-by-day snapshot history (price churn, delisting), and charges $0.01/call. This is significant context beyond a simple 'lint' statement.

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

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

The description is front-loaded with the core action and quickly explains the scoring mechanism and cost. It is a single sentence with multiple clauses, but every clause adds necessary information about the tool's function and components, so it earns its length.

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

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

Given a single-parameter schema and no output schema, the description is quite complete. It explains what the tool returns ('0-100 quality score'), what inputs it analyzes, and the cost. It does not detail the exact output format, but for a lint tool this is sufficient. The usage context is also provided.

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 for the single parameter 'resource' with a description 'The listed resource URL to lint'. The description adds no new parameter-level detail, but the schema is already sufficient. Baseline 3 applies because the description does not need to compensate.

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

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

The description uses a specific verb+resource: 'Lint an x402 Bazaar listing', and clarifies the purpose with 'before buying or before publishing your own'. It clearly distinguishes from sibling tools like bazaar_market_report or bazaar_delta by focusing on a single listing's quality score.

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

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

The description explicitly states when to use the tool: 'before buying or before publishing your own'. It implies the tool is for pre-transaction validation, but does not name alternatives or exclusions. This is clear context, yet lacks explicit 'when not to use' 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?

With no annotations, the description carries the full burden. It discloses the data source (daily full-catalogue snapshots), the cost ($0.50/call), and what is included. It does not mention rate limits or authentications, but for a read-only report, these are less critical. The cost disclosure is a valuable behavioral trait.

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

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

The description is compact, front-loaded with the tool's purpose, and every sentence provides value. It lists contents efficiently and adds cost and snapshot timing without 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?

For a zero-parameter tool with no output schema, the description is complete. It tells the agent exactly what to expect (a JSON dossier with named metrics), the data timeliness, and the cost. This is fully sufficient for selecting and invoking the tool.

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

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

The tool has zero parameters, so there is nothing to document. The description adds useful context about the report's content and freshness without needing to explain params. Baseline 4 is appropriate.

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

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

The description clearly states the tool provides 'the full state of the x402 Bazaar in one JSON dossier' and enumerates the included metrics (totals, price distribution, network split, top services/sellers, etc.). This specific verbless statement thoroughly differentiates it from sibling tools that focus on individual 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 when to use it naturally: for a comprehensive market overview. It says it's built from daily full-catalogue snapshots and costs $0.50/call, providing context. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a perfect score.

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?

Since no annotations are provided, the description fully discloses the tool's behavior: it compares daily snapshots to derive new listings, returns specific fields (service, network, price, seller address), and states the cost of $0.003/call via x402. This is comprehensive and transparent for a read-only query 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 that is front-loaded with the core purpose, followed by the method and cost. It is concise, with no filler or redundant information, and every phrase adds value.

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

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

Even without an output schema or annotations, the description provides enough context to understand the tool's behavior, including the exact selection algorithm and output fields. For a simple tool with no parameters, this is a complete and self-explanatory description.

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

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

The tool has zero parameters, so the schema provides no additional meaning. The description compensates by explaining what the tool does and what it returns. According to the baseline for zero parameters, this is a high 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?

The description clearly states the tool's function: identifying resources newly listed on the x402 Bazaar. It specifies the exact resource (x402 Bazaar), the verb (just listed), and the scope (everything in the latest daily snapshot missing from the prior one), which distinguishes it from sibling tools like bazaar_delta or bazaar_category_heat.

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

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

The description makes the intended use clear by phrasing it as a question ('Which resources just listed...'), indicating it is used to discover new listings. However, it does not explicitly mention when not to use the tool or suggest alternative sibling tools, so it falls short of a perfect score.

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 adds valuable behavioral context: the data comes from 'the latest daily full-catalogue snapshot' (indicating potential staleness), the cost is disclosed ($0.002/call via x402), and the optional network filter is described. It does not mention output format or error behavior, but given the read-only nature, the key traits are covered.

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 two sentences, front-loaded with the core function, and contains no fluff. It efficiently conveys the stats provided, the snapshot source, the optional filter, and the cost. Every sentence earns its place.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential context: what data is returned (percentiles, price bands, medians), the data source (daily snapshot), and cost. It could mention the response structure or error handling, but for a stats query, the description is largely complete. Slightly more detail on return format would push it to a 5.

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

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

The only parameter, network, is fully described in the schema with an example and instruction to omit for all networks. The description repeats this via 'Optionally filter to one network.' Since schema coverage is 100%, the description adds no new semantic meaning beyond what the schema already provides. 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 what the tool does: it provides a percentile distribution (atomic + USD), USD price bands with market share, and per-network medians for x402 Bazaar listings, based on a daily snapshot. This is a specific, distinct function compared to sibling tools like bazaar_pulse or bazaar_trending, which focus on other aspects. The purpose is immediately clear.

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 context—'How x402 Bazaar listings are priced right now'—and mentions the optional network filter, but it does not explicitly state when to use this tool versus alternatives like bazaar_market_report or bazaar_delta. There are no exclusions or alternative tool recommendations, so the guidance is implied rather than 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?

No annotations are provided, so the description carries the full burden. It discloses the cost ('$0.002/call via x402') and the data freshness ('latest completed daily snapshot'), which are useful behavioral traits. However, it does not mention return format, error conditions, or any rate limits, leaving some behavioral uncertainty for a zero-parameter 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, well-structured sentence that front-loads the primary purpose and includes critical details (contents, freshness, cost). Every word earns its place with no redundancy or extraneous 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 the tool's low complexity (zero parameters, no output schema), the description covers the essential aspects: source, contents, frequency, and cost. It does not explain output structure, but that is not necessary when no output schema exists and the tool is a straightforward data snapshot. A perfect score would require distinguishing guidance from 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?

The tool has zero parameters, so the description does not need to explain any. The baseline for 0 params is 4, and the description appropriately focuses on the tool's output rather than input, which is irrelevant here.

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

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

The description clearly identifies the resource ('x402 Bazaar market pulse') and specifies its contents ('catalogue totals, top services by call volume, new listings and networks'). While it lacks an explicit verb like 'get' or 'list', the intent is unambiguous. It distinguishes from siblings by naming 'x402 Bazaar' specifically, though it doesn't differentiate from the similar-sounding 'market_intel'.

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 state when to use this tool versus alternatives. It mentions 'latest completed daily snapshot' implying a use case for fresh data, but there is no explicit guidance on when not to use it or what alternatives exist. With multiple sibling tools offering market data, this gap is noticeable.

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 of behavioral disclosure. It reveals that the tool uses the latest daily snapshot, focuses on settled 30d calls, and lists specific data included. It also mentions the call cost ($0.003 via x402), adding useful context beyond what schema or annotations provide. However, it does not explicitly state read-only nature or potential rate limits, but for a simple data query, this is adequate.

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 two sentences, tightly packed with relevant detail: ranking criteria, time window, snapshot source, included fields, and cost. Every phrase earns its place with no redundancy, and the key purpose is front-loaded in the first few 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 zero-parameter query tool, the description is remarkably complete. It explains what data is used (latest daily snapshot), the metric (settled 30d calls), the ranking scope (top 25), and the output components (listings, unique payers, busiest resource). No output schema exists, but the description effectively communicates the return content.

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

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

The tool has zero parameters, so there is nothing for the description to clarify. The description instead focuses on what the tool returns, which is more relevant. Per rubric, a baseline of 4 applies when there are no params.

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: ranking top 25 x402 Bazaar seller addresses by settled 30d calls. It specifies the exact output content (listings, unique payers, busiest resource) and distinctively differs from sibling bazaar tools like bazaar_market_report or bazaar_pulse, which focus on broader market trends rather than individual seller ranks.

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 opening phrase 'Who is actually earning on the x402 Bazaar' gives a clear use case, implying it is for identifying top-earning sellers. It does not explicitly mention alternatives or when not to use it, but the context is clear enough that an agent can infer when this tool 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 of behavioral disclosure. It reveals the data source (daily full-catalogue snapshots), comparison method (day-over-day), output categories, and cost ($0.003/call via x402). This goes beyond a generic description, though it does not explicitly state read-only behavior or output format.

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-constructed sentence that front-loads the core question and includes all essential details: the resource (Bazaar services), metrics (settled calls, unique payers), time frame (day-over-day), categories (movers, decliners, new entrants), data source, and cost. 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 zero-parameter tool with no output schema, the description is reasonably complete: it explains the conceptual output, the cadence of snapshots, and the pricing. It does not detail the exact result structure, but the absence of an output schema makes that less critical. It could also mention that it is read-only, but the context 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 tool has zero parameters, so the schema is fully covered. Per the baseline for 0-parameter tools, the description does not need to add parameter details. It could mention that no input is required, but the context signals make this unnecessary.

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: identifying which x402 Bazaar services are gaining settled calls and unique payers fastest, with specific categories (day-over-day movers, decliners, and new entrants). This distinguishes it from sibling tools like bazaar_pulse or bazaar_delta by specifying exact metrics and snapshot basis.

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 discovering currently trending Bazaar services ('gaining... fastest right now') but does not explicitly state when to use this tool over alternatives or provide exclusions. No sibling tool references are given, leaving some ambiguity for an agent choosing between related bazaar_* 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?

Without annotations, the description carries full burden for behavioral disclosure. It mentions 'ephemeral' and '$0.02/call,' which add some context, but it does not explain failure behavior, side effects, authentication requirements, or what AEP-1.0 evidence actually contains. The lack of an output schema makes this gap significant for a browser automation 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, compact sentence that includes the core behavior, cost, and evidence format. Every phrase contributes meaning, with no filler or redundancy.

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

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

This tool has nested parameters, no annotations, and no output schema, yet the description is extremely short. It omits critical details like how the action object should be structured, what AEP-1.0 evidence includes, and how results are returned, making it incomplete for a tool of this complexity.

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 0%, so the description must compensate for all parameters. It only partially explains 'expected' via 'selector or text assertion.' The action object's types (click/type/goto), the purpose of url, and the role of request_id are entirely unexplained, leaving agents without the needed semantics for invocation.

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

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

The description specifies a clear action: 'Run one ephemeral Playwright browser action and verify a selector or text assertion, returning AEP-1.0 evidence.' This identifies the resource (browser action), the operation (verify), and the output (evidence), effectively differentiating it from siblings like web_extract or batch_url_json.

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 explicit guidance on when to use this tool versus alternatives like web_extract or purchase_web_extraction_sample. It implies usage through its description but lacks any when/when-not context 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?

No annotations are present, so the description carries the full burden. It adds valuable behavioral guarantees: 'the answer is validated against your label list' ensures a real label is returned, and the pricing ($0.005/call via x402) is an extra non-obvious detail. It does not cover failure modes, but the tool's simple classification behavior makes this less 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 well-structured sentence that front-loads the action and packs in the label constraint, use cases, validation guarantee, and pricing. Every phrase earns its place with no filler.

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

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

This is a simple two-parameter tool, and the description plus schema fully specify inputs, output behavior (exactly one label), validation, and cost. No output schema is needed because the labels parameter already states the return characteristic, and the description adds meaningful context for real-world 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 description coverage is 100%—both parameters are fully described in the schema (text truncation, label constraints, response guarantee). The description's mention of '2-20 labels' and the response being one of them largely repeats schema content, providing no new parameter-specific meaning beyond 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 opens with a specific verb and resource: 'Classify text into exactly one of your 2-20 labels.' It also names concrete applications (support triage, intent detection, content routing) that immediately distinguish it from sibling tools like sentiment or extract_keywords.

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 usage context by listing example applications, and the phrase 'your 2-20 labels' implies it is for custom labels. However, it does not explicitly mention when NOT to use it or name alternative tools, so it lacks explicit exclusions or 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 carries the full burden. It adds valuable behavioral context: cost ($0.50/call), output expectation (citations), and data sources (SEC EDGAR + web). It does not disclose potential failure modes or output structure, but for a read-only research tool this is a solid disclosure.

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

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

The description is two short sentences, front-loaded with the action and resource. Every phrase ('SEC EDGAR filings', 'web sources', 'with citations', '$0.50/call') conveys necessary information without 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 tool with two simple parameters, no output schema, and no annotations, the description is reasonably complete. It identifies purpose, sources, output expectation, and cost. It omits any mention of coverage restrictions (e.g., US companies only) or response format, but these are not critical for invocation.

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

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

Ticker is already described in the schema, and filing_type is an enum with a default. The tool description mentions 'SEC EDGAR filings' which provides context for filing_type, but does not explain the specific filing types or their differences. With schema coverage at 50%, the description adds only marginal parameter-level meaning.

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

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

The description states a specific action ('Research'), a clear target ('public company'), and distinguishes itself by naming data sources ('SEC EDGAR filings plus current web sources') and output characteristic ('with citations'). This clearly separates it from sibling tools like web_extract or market_intel, which have different scopes.

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 context for use is explicit: research a public company with SEC and web sources. It implies usage for due diligence or source-backed company queries. However, it does not explicitly compare itself to alternatives or state when not to use it (e.g., for private companies), so it falls short of a 5.

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

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

No annotations are provided, so the description must convey behavioral traits, but it only mentions a per-call cost. It does not disclose whether the tool creates persistent state, requires authentication, has side effects, or what the output format is.

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

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

Two sentences with no filler; the first states the core purpose and the second adds pricing information. It is front-loaded and easily scannable.

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

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

Despite the tool's complexity (7 required params, no output schema, no annotations), the description is minimal and omits critical context such as return value structure, behavioral constraints, and parameter semantics. It is not complete enough 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 has seven required parameters with zero descriptions, and the tool description does not explain any of them. The mention of 'refund rules' loosely relates to refund_capability, but the other six parameters (e.g., product_type, max_latency_ms) are completely unaddressed.

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

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

The description uses a specific verb ('compile') and resource ('multi-rail merchant payment policy') with a list of rule types, making its function clear. It does not name alternative tools or explicitly differentiate from siblings, but the scope is distinctive.

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 information about when to use this tool, what triggers its use, or how it compares to sibling tools like settlement_verify or x402_receipt_lookup. There are no usage conditions or exclusions stated.

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

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

With no annotations, the description carries the transparency burden. It adds useful context about live market data, source attribution, and cost, but does not disclose behavior such as error handling, response shape, or whether the price is cached/paginated.

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 packs purpose, data source, attribution, and cost. No wasted words or redundant details.

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 price lookup, the description covers the essential purpose and adds cost and source attribution. The lack of an output schema is mostly mitigated by stating the price and source, though a brief mention of the response structure would make it 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 symbol parameter is fully documented in the schema with an example. The description only repeats 'one token symbol' and adds no additional semantics about format, case sensitivity, or accepted values.

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 the current USD price for a single token symbol using live market data. It mentions the specific resource (token price) and scope (one symbol), but does not explicitly contrast with similar siblings like token_metrics or market_intel.

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

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

Usage is implied: use when you need a quick USD price for one token. However, there is no explicit guidance on when to choose this over sibling tools, nor any mention of limitations 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 must carry the burden. It discloses the $0.05/call cost via x402, which is useful, and states it returns result rows. However, it does not disclose potential side effects, rate limits, response format limitations, or failure behavior, 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 two concise sentences, front-loaded with the action ('Execute'), includes cost info, and avoids verbosity. Every word adds value.

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 or annotations, the description is fairly complete. It explains what the tool does, what it returns, and the cost. It could optionally mention query limits or output formatting, but given the simplicity, the current description 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?

The input schema has 100% coverage for the sql parameter with a description and example. The tool description adds context by mentioning 'on-chain datasets' but does not substantially enhance understanding of the parameter beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description clearly states the tool executes a Dune Analytics SQL query against on-chain datasets and returns result rows. This is specific in verb and resource, and distinguishes it from siblings like crypto_price or web_extract, which have 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 usage for running Dune SQL queries on on-chain data, but does not explicitly state when to use vs alternatives or when not to use it. Since no other sibling tool provides SQL execution, the context is implicitly clear but lacks explicit 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?

With no annotations provided, the description discloses the tool's side effects: it's a non-mutating echo, requires x402 payment, and costs $0.01/call. It adds meaningful context beyond the schema, though it doesn't detail response format or failure 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?

Two sentences, front-loaded with the core action, followed by the diagnostic context and cost. No redundant filler.

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

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

As a simple diagnostic echo tool, the description covers purpose, cost, and behavioral context sufficiently. It doesn't specify the timestamp format, but that's a minor detail for an echo endpoint.

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 has zero defined properties but allows arbitrary query parameters with a clear description. The tool's description reinforces that query parameters are returned verbatim, and since parameters are free-form, there is little more to explain.

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 echoes request query parameters back with a timestamp, and identifies it as an x402 client diagnostic. This specific verb+resource makes it distinct from the sibling analysis 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?

It conveys a diagnostic use case ('exercises the payment headers, not just the HTTP client') and mentions cost, implying it's for testing x402 integration. However, it doesn't explicitly state when not to use it or name an alternative, but given the sibling set, the context is sufficient.

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 behaviors: the request is bounded, costs $0.01, and the target body is not returned. However, it does not warn about sending user-supplied headers/body to arbitrary endpoints or discuss side effects, prerequisites, 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?

The description is a single dense sentence that efficiently conveys the verb, resource, output scope, constraint (no body), and cost. Every clause adds value with no redundancy.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description covers the core purpose, return fields, and constraints. It lacks details on assertion validation or method defaults, but the schema partially fills that gap.

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

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

Schema coverage is 60% with descriptions for target_url, headers, and task_assertions, but method and body lack descriptions. The description adds no parameter-specific detail beyond noting the request is bounded and x402-related, leaving some parameters under-explained.

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 makes one bounded request to a public HTTP endpoint and reports specific data (status, x402 payment signals, latency, assertion validity). It also explicitly notes the target body is not returned, distinguishing it from siblings like web_extract.

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 lightweight HTTP endpoint testing with a cost per call, but it does not explicitly state when to choose this tool over alternatives or mention any exclusions. No direct 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?

With no annotations, the description carries the full burden and does excellently: it discloses parse-validation, automatic retry, and a clean failure mode. It also mentions cost. These behavioral traits go well beyond the schema, which only defines the inputs.

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 main purpose, then adds behavioral details and cost. Every clause earns its place 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?

For a simple two-parameter tool with no output schema, the description adequately covers purpose, behavior, failure modes, and cost. It does not need to explain return values since the output is described as JSON or a clean failure, and the schema param is self-explanatory.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds examples of text types but no additional syntax or constraints beyond the schema. The baseline of 3 is appropriate; the description does not meaningfully enhance parameter understanding.

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 converts unstructured text into structured JSON using a provided JSON Schema, with specific examples (emails, invoices, listings, bios). This is a specific verb+resource and distinguishes it from siblings like extract_keywords or classify_text.

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

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

It provides clear context for when to use the tool (when you have unstructured text and a JSON schema), but it does not explicitly name alternatives or exclusion criteria. The use case is well-defined, but no 'vs alternatives' guidance is given.

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

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

No annotations are provided, so the description carries the full burden. It mentions the output format ('clean JSON arrays') and pricing, but omits important behavioral details like the 8,000-character truncation limit, rate limits, or auth requirements. This leaves 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 front-loads the main action, includes pricing, and uses no filler. Every word contributes to conveying purpose and value.

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

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

The description covers purpose, output format, use cases, and pricing. The schema covers the parameters. While it doesn't mention the 8,000-character truncation limit, that is available in the schema. The lack of an output schema makes the 'clean JSON arrays' statement somewhat vague, but overall it is adequately complete for a simple extraction tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context about ranked output and entity types (people, orgs, places, products), but it does not specifically explain the parameters beyond what the schema already provides. It enhances understanding of the output, but not the parameters themselves.

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 extracts ranked keywords and named entities from text, using a specific verb and resource. It distinguishes itself from sibling tools like classify_text or summarize_text by focusing on extraction and entity recognition.

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

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

The description provides explicit use cases ('for tagging, indexing, and enrichment pipelines'), giving clear context for when to use it. However, it does not mention alternatives or exclusions, so it stops short of a full 5.

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

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

With no annotations provided, the description carries the full burden. It discloses automatic payment handling, cost ($0.02/call), free tier limits (1 fetch/day), and that it returns payment proof. This is valuable behavioral information beyond the input schema, though it doesn't cover failure modes 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 extremely concise: two sentences that front-load the main purpose and include cost/free tier info. Every word earns its place, with no redundancy or filler.

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

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

For a tool with no output schema and moderate complexity (payment handling, multiple formats), the description provides enough context: purpose, cost, free tier, return content. It doesn't explain error cases or detailed usage, but it's sufficient for an agent to decide when to call it and what to expect.

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 all three parameters with reasonable detail (URL must be https, format enum, selector note). The description adds context about output being 'clean article content' and mentions 'content only' for the free tier, but doesn't deeply elaborate on parameter meanings. With 67% schema coverage, a baseline of 3 is appropriate.

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

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

The description uses a specific verb 'Fetch and extract' with a clear resource ('x402-protected web pages') and scope ('handling edge payment automatically'). It distinguishes itself from generic tools like web_extract by focusing on x402-protected content and automatic payment.

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

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

The description clearly implies when to use this tool: for x402-protected pages where edge payment is needed. It doesn't explicitly name alternatives or exclusions, but the automatic payment handling is a strong contextual indicator that sets it apart from ordinary fetch 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?

With no annotations provided, the description carries the full transparency burden. It discloses a critical behavioral trait: each call costs $0.01 and requires payment via specific schemes (exact payment on Base/Solana or the Base 'upto' scheme). It also reveals OpenAI API compatibility, implying standard request/response behavior. It does not cover failure modes or error handling, but the disclosed cost/payment model is substantial value beyond the name and schema.

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

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

The description is two sentences with the core purpose front-loaded in the first sentence. The second sentence packs in essential pricing details (exact amounts, chains, payment schemes) without padding. It is slightly dense but every phrase conveys necessary cost information, so little is wasted.

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

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

The tool has only 3 parameters, all documented in the schema, and the description covers the gateway context and the mandatory payment requirement. The OpenAI-compatibility reference and model catalogue pointer add operational context. It lacks explicit guidance on message format and sibling differentiation, but for a straightforward API wrapper with full schema coverage, the description is reasonably 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 description coverage is 100%, so the baseline is 3. The description's mention of the model catalogue (/api/v1/models) duplicates the schema's own model description, adding no new parameter semantics. The payment information relates to the tool as a whole, not to individual 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 opens with a specific verb-resource pair: "OpenAI-compatible chat completion through the ZenMux model gateway." This clearly distinguishes it from sibling tools like summarize_text or classify_text, which are higher-level text processors. It states exactly what the tool provides (chat completions) and via which infrastructure.

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 only implied: the description identifies it as a generic chat completion tool and references the model catalogue, but it does not explicitly state when to use this raw tool versus higher-level siblings like answer_with_sources or rewrite_text. No when-not-to-use guidance is provided. The pricing details serve as a cost signal but not as an explicit usage guide.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses a specific behavioral trait—cost ($0.01/call via x402)—and implies a read-only analytical function, but does not explicitly state whether it writes, requires authentication, or describe failure 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 two sentences, front-loads the core purpose, and includes all essential information without redundancy. Every clause adds value, from the action to the cost model.

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

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

Given the lack of an output schema, the description does a good job of outlining what the tool returns (persistence, price changes, duplicate variants, buy signal). It is complete for a single-listing analysis tool, though it could clarify matching behavior when both name and URL are provided.

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

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

The input schema has 100% description coverage for both parameters (listing_name and listing_url), so the schema already provides the meaning. The description adds no additional parameter-level detail beyond the schema, earning a 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 uses a specific verb 'Triage' with a clear resource ('one Bazaar listing') and enumerates distinct outputs (persistence, price changes, duplicate variants, buy signal). This clearly distinguishes it from sibling tools such as bazaar_pulse or market_intel.

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

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

The description clearly states the tool is for triaging a single listing against its snapshot history, implying usage when a user needs a historical assessment of one listing. It does not explicitly name alternatives or exclusions, but the context is clear enough.

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

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

With no annotations, the description carries the burden. It does disclose a key behavioral aspect: '$0.10/call via x402' (cost) and that it aggregates data from Dune and public web sources. However, it does not state whether it is read-only, how long it takes, or any rate limits, which would be useful.

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 concise sentence that front-loads the core purpose, then adds data sources and cost. Every word earns its place without redundancy.

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

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

Given the tool's complexity (a multi-source research report) and lack of output schema, the description adequately conveys what it does and what sources it uses. It could improve by hinting at the report's format (e.g., text, JSON) or typical use cases, but it is largely complete for potential users.

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

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

The input schema has 100% description coverage for all parameters, so the description adds limited value here. The mention of 'crypto project' and 'Dune on-chain metrics' implicitly maps to the project/token_address and chain parameters, but no additional syntax or detailed semantics are provided.

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 produces an 'Intelligence report on a crypto project' using Dune on-chain metrics and public web sources, which distinguishes it from siblings like dune_query or token_metrics. However, it lacks a strong verb (e.g., 'generates', 'compiles'), making it slightly less direct than ideal.

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

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

There is no explicit guidance on when to use this tool versus alternatives like dune_query, crypto_price, or sentiment. The description only implies that it is for comprehensive research, but does not provide exclusions 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 the full burden of behavioral disclosure. It discloses cost ($0.01/call via x402), boundedness, and that it targets one HTTPS page. However, it omits details about the output format, idempotency behavior, and failure modes, which are critical for a paid operation.

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 two short sentences, front-loaded with the core action and pricing. Every word contributes meaning, and there is no redundancy or filler.

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

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

There is no output schema or annotations, so the description must explain what the agent receives and any usage context. It fails to describe the return value (e.g., the extracted content structure), how the idempotency key works, or the exact limits of the 'bounded' sample. This is a significant gap for a paid 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 only 50% (url has a description, idempotency_key does not). The tool description does not clarify the purpose of idempotency_key and merely restates the URL requirement already present in the schema, adding no new parameter 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 states the action ('buy') and the resource ('a bounded machine-readable extraction sample from one HTTPS webpage'). It also includes the cost and protocol, which helps differentiate it from free extraction tools, though it does not explicitly name alternatives.

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 web_extract or fetch_x402_content. The description implies it is for inexpensive sample extraction but does not state prerequisites, exclusions, or scenarios where other tools are preferred.

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.05/call via x402) and implies web fetching from supplied URLs, which are useful behavioral traits in the absence of annotations. However, it does not cover failure modes, idempotency behavior, or what happens with invalid URLs, leaving the return format and side effects 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 just two sentences with no wasted words, and it front-loads the core action and cost. However, the term 'decision packet' is vague and could be unpacked further without adding much length.

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

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

As a paid tool, the description is inadequate for safe invocation. It does not explain what the decision packet contains, how to interpret results, prerequisites like having x402 credits, or when to use this instead of free alternatives. The absence of an output schema increases the burden, and the description fails to meet it.

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

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

The description maps 'supplied URLs' to the urls parameter and 'question' to the question parameter, but provides no details on idempotency_key or constraints like max 5 URLs or string length. With 0% schema description coverage, the description only partially compensates for the missing parameter documentation.

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

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

The description clearly states the action (purchase) and the resource (sourced website decision packet), and mentions inputs (URLs and a question). However, it does not define what a 'decision packet' is, and it doesn't explicitly differentiate from sibling tools like answer_with_sources or web_extract.

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 where a paid decision packet is preferable to free tools like web_extract or answer_with_sources, nor any exclusions 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?

With no annotations provided, the description takes on the full burden of disclosing behavior. It adds useful details: deterministic output and cost ($0.005/call). It does not mention output format or error handling, but for a simple tool this is sufficient.

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, front-loaded sentence that states the purpose, gives examples, and notes cost and determinism without any 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?

Given the tool's simplicity (2 params, full schema coverage, no output schema), the description provides a complete picture: what it does, examples, and key behavioral traits. It could mention return value explicitly, but that is implied by 'rewrite'.

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

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

The schema already documents both parameters with descriptions (100% coverage), and the description enriches understanding by providing concrete instruction examples and the range of transformations (tone, formality, length, reading level), adding value beyond the schema.

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

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

The description clearly states the tool's function with a specific verb ('Rewrite text') and defines the scope ('to match an instruction'), including examples of transformations. It distinguishes itself from sibling tools like summarize_text and classify_text by focusing on rewriting rather than summarization or classification.

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: whenever text needs rewriting to match an instruction. However, it does not explicitly mention alternatives or exclusions, but the examples imply specific use cases, so it meets the 'clear context, no exclusions' level.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It proactively discloses the $0.01/call x402 cost, the free-tier limit of 3 queries/day/wallet, and that the free tier returns only the top-1 result. This is valuable beyond the schema. It does not mention failure modes or response format, but the cost and output limitations are well communicated.

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 two sentences, front-loaded with the core purpose and filter options, followed by pricing and free-tier limitations. No wasted words or redundant information relative to the schema.

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 moderate complexity (nested constraints, payment model, multiple catalogs) and no output schema, the description covers the purpose, filter options, cost, and free-tier behavior. It does not explicitly disambiguate from sibling routing/evaluation tools like endpoint_task_evaluation or listing_triage, and it omits the response format. However, it provides enough context to correctly select and invoke the tool.

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

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

Schema coverage is 50% (the 'task' property has a description; the 'constraints' object lacks a top-level description but its sub-fields have descriptions). The description text adds 'optional price/chain/category filters', which mirrors the constraints schema but does not add deeper semantic detail about the expected format or usage. The 'task' parameter is described as natural language in both the schema and description, adding no new meaning. With partial coverage, the score is baseline 3.

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

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

The description clearly states it is a 'task router' that 'rank endpoints from MPP catalog, Apify actors, and Bazaar listings by task description' – a specific verb, resource, and scope. It distinguishes this tool from siblings like listing_triage and endpoint_task_evaluation by naming its exact sources and routing 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?

The description clearly conveys when to use the tool: when you have a natural language task and need to find the best endpoint across specific catalogs. However, it does not explicitly state when not to use it or mention alternative sibling tools, though the cost/free-tier details provide additional use-case context. Clear context, but no 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 annotation is absent, so the description carries the burden of disclosure. It does disclose a paid API cost ($0.05/call via x402), which is useful. However, it does not disclose the output format (e.g., score vs label), read-only nature, or behavior when both parameters are provided, leaving important 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, concise sentence that front-loads the core functionality and includes essential cost information. Every word adds value, with no redundant or unnecessary content.

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

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

Given the absence of annotations and output schema, the description should explain the return value and clarify the parameter relationship (one-of). It fails to do so, leaving the agent without critical information about what to expect from the tool. The pricing disclosure is helpful but insufficient for completeness.

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 provides descriptions for both 'text' and 'topic' (100% coverage). The description essentially paraphrases these ('supplied block of text' vs 'current coverage of a named topic') without adding new meaning, meeting the baseline but not enriching it.

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

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

The description clearly states the tool performs sentiment analysis on either a supplied text block or a named topic. This is specific and distinguishes it from all sibling tools, which do not explicitly cover sentiment analysis.

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 explicit guidance on when to choose this tool over alternatives, nor does it specify constraints like 'provide either text or topic, not both'. It merely implies usage by defining the two input modes, but does not contrast with sibling tools or mention 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 carries the full burden. It discloses the key behavioral trait: 'returned only after settlement,' and notes the cost per call ($0.01/call). This is valuable context beyond the basic output description, though it does not cover potential failure modes or exact response 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 two concise sentences: the first states the output and the payment gate, the second adds the cost and use-case context. It is front-loaded and every phrase earns its place with no redundancy.

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

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

For a simple parameterless tool, the description covers the output format (ISO 8601 + Unix epoch), the settlement requirement, and the cost. Since no output schema exists, a more explicit response structure would improve completeness, but it is already functional for an agent to invoke the tool correctly.

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

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

The tool takes zero parameters, so the schema is fully self-explanatory. The description adds no parameter details, but none are needed. Baseline 4 is appropriate.

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

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

The description clearly states it returns the current server time as ISO 8601 and Unix epoch, specifying the exact data provided. This is a distinct, specific resource unlike any sibling tool, so it fully clarifies the tool's 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?

The description frames this as 'the smallest end-to-end probe of the x402 payment path,' giving clear context for when to use it (testing payment integration). It does not explicitly name alternatives, but the sibling list contains no similar tool, so the guidance is sufficient.

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 several behavioral traits: performs a real on-chain lookup, decodes specific USDC Transfer event fields, returns a verification_id for later re-fetch, and costs $0.01 via x402. It does not detail edge cases like invalid tx_hash or network failures, but covers core behavior well.

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

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

Two sentences, front-loaded with the main purpose. The first sentence efficiently lists key features in a compact list, and the second states pricing. No redundant 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?

Despite lacking an output schema, it enumerates the expected return data (receipt lookup, decoded events, status, confirmations, verification_id). It also notes cost. Given the modest parameter set, the description is sufficiently complete for an agent to decide and invoke.

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 both parameters (tx_hash format and chain_id default/limitation) with 100% coverage. The description adds context about the purpose (verifying x402 settlement) but does not add new parameter-level details 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?

Begins with a specific verb+resource: 'Verify an x402 settlement actually landed on Base mainnet.' It clearly distinguishes itself from sibling tools by enumerating unique capabilities: real JSON-RPC receipt lookup, decoded USDC Transfer events, success/reverted status, confirmation count, and stored verification_id.

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

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

Provides clear context: it is for verifying an x402 settlement on Base mainnet after the fact. The mention of 'real JSON-RPC receipt lookup' implies a more thorough check than simpler status tools, but it does not explicitly name alternatives or state when not to use it.

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

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

No annotations are provided, so the description carries the burden. It adds value by disclosing determinism (temperature 0), flash-model selection, and pricing context, but lacks deeper detail on output format edge cases or failure 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?

A single, information-dense sentence that front-loads the core purpose and appends relevant constraints (deterministic, cost) without padding.

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

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

For a simple two-parameter tool without an output schema, the description covers purpose, output styles, and operational context (determinism, cost). It implicitly defines the return as the summarized text, though not explicitly.

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

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

The input schema fully describes both parameters (text and style) with descriptions and an enum, so the description adds no new parameter-level information. Baseline 3 applies given >80% schema coverage.

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

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

Description clearly names the verb 'Summarize' and the resource 'any text', plus lists three output styles. This distinguishes it from siblings like classify_text, extract_keywords, and rewrite_text.

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 implies the tool is for agent pipelines and notes deterministic behavior and cost, but does not explicitly state when to prefer it over alternative text-processing tools or 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?

Since no annotations are provided, the description carries the full burden of disclosing behavior. It implies read-only access to on-chain balances but does not explain how metrics are computed, data freshness, potential failure modes (e.g., unsupported token standards), or what the actual output structure looks like. It only adds the cost detail, which is useful but not 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 extremely concise at just two short clauses, yet it conveys the core purpose, the specific metric categories, and the cost. Every word is informative, and the structure front-loads the most important information. No filler or redundancy.

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

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

Given the tool's relative simplicity (2 params, no output schema, no annotations), the description covers the topic and cost but leaves gaps in behavioral clarity and output expectations. It doesn't state what the result looks like or how to interpret the metrics, which is important when no output schema exists. It is adequate 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?

The schema already describes token_address as an ERC-20 contract address and chain via an enum with a default. Schema coverage is 50%, which is not low, so the baseline of 3 is appropriate. The description adds the semantic context that the metrics are derived from on-chain balances, but it does not elaborate on parameter format or interactions beyond what the schema provides.

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

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

The description clearly states the tool provides 'token fundamentals from on-chain balances' and lists specific metrics (holder distribution, concentration, whale ownership), which distinguishes it from price-focused siblings like crypto_price. However, it lacks an explicit verb (e.g., 'get' or 'list'), making it a noun phrase rather than a full action statement.

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 state when to use this tool or when to prefer alternatives. It only mentions the cost of $0.03/call, which is not a usage guideline. There is no comparison to sibling tools or exclusion conditions, so an agent is left to infer applicability solely from the tool name and metrics.

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: it specifies the data source (Dune on-chain), the scoping (one token), and the cost ($0.05/call via x402). However, it doesn't disclose the output format, whether it's real-time, or any rate limiting beyond cost, so it is minimally adequate.

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

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

Two short sentences, first stating purpose with concrete data components, second stating cost. No fluff, front-loaded, every word 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 low-complexity tool with two optional params and no output schema, the description covers purpose, data source, and cost. It lacks any indication of what the signal output looks like (e.g., buy/sell recommendation, score) and which chains are supported beyond the default, leaving some gaps.

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

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

Schema coverage is 100% with descriptions for both parameters, so the baseline is 3. The description's mention of 'one token' implicitly relates to the symbol parameter but adds no detailed semantics beyond the schema.

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

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

The description clearly identifies the tool as providing trading signals for a single token based on Dune on-chain data, listing specific data components (whale transfers, token flows, DEX volume). It distinguishes from siblings like crypto_price (price-only) and dune_query (raw queries), though it lacks an explicit verb like 'get'.

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

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

No when-to-use guidance or alternatives are mentioned. The description only states what the tool does and its price, leaving the agent to infer when to choose it over siblings like token_metrics or market_intel.

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 must disclose behaviors. It mentions cost and time period but does not explicitly state that it is read-only, nor any rate limits, authentication, or other side effects. This is a gap for a tool that makes API calls.

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

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

The description is a single sentence that front-loads the core purpose and includes a cost note, 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?

Without an output schema or annotations, the description is incomplete. It does not describe the return format, data structure, or any limitations. Given the complexity of the analysis, more detail 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 schema documents wallet_address with a pattern and chain as an enum with default. The description does not add meaning to these parameters; it mentions the wallet and analysis scope but not how chain selection affects the analysis. With only 50% schema coverage, the description fails to compensate.

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 analyzes an EVM wallet over 90 days, listing specific data points like transfer activity, counterparties, token flows, and active days. It uses a specific verb ('Analyze') and resource ('EVM wallet'), but does not differentiate from the similarly named sibling 'wallet_spy', so it lacks sibling distinction.

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 wallet_spy or other analysis tools. It only describes what it does with no context for 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?

With no annotations, the description carries the burden of behavioral disclosure. It mentions the heuristic nature of the risk score and the cost, but does not explicitly state that the operation is read-only or disclose rate limits, authentication needs, or error behavior. The word 'Inspect' implies a safe lookup, but more context could be added.

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, front-loaded sentence that begins with the action and resource, lists the key data categories, and ends with cost. Every element earns its place; there is no fluff or redundancy.

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

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

For a moderately complex tool with no output schema, the description lists the main output categories (transactions, flows, swaps, NFTs, counterparties, risk score), giving a solid sense of what is returned. It lacks some usage nuance (e.g., chain scope) but overall provides sufficient context for an agent to understand the tool's scope.

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 50% (only 'address' has a description). The description does not add meaning to 'chain' beyond the enum/default in the schema, nor explain how chain selection affects results. It fails to compensate for the undocumented chain parameter, leaving the agent without guidance on chain 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 the tool's purpose: 'Inspect an EVM wallet' and enumerates specific data categories such as transactions, token flows, DEX swaps, NFT activity, counterparties, and risk score. It is specific but does not explicitly differentiate from the sibling tool 'wallet_analyze', which may overlap in functionality.

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 inspecting wallet activity, but provides no explicit guidance on when to choose this over wallet_analyze or other alternatives. It lacks any 'when not to use' or alternative tool references, so usage is merely implied rather than 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?

With no annotations provided, the description carries the transparency burden. It discloses that only public pages are fetched and specifies the output format and cost. However, it omits potential limitations like page size, timeouts, or handling of non-HTML content, leaving moderate 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, concise sentence that front-loads the action ('Fetch') and resource ('public web page'), includes the output structure, and adds relevant cost information. 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?

The tool is simple with one parameter and no output schema. The description covers the main output fields and the public-page constraint, which is sufficient for an agent to decide to use it. Minor caveats like page size limits or JavaScript rendering are not critical for basic use, so this is reasonably 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 schema already documents the url parameter with a description and format, achieving 100% coverage. The description adds nuance that the URL must be a public web page, but this is a minor extension beyond the schema, keeping the score at 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 explicitly states the tool fetches a public web page and returns structured JSON with title, text content, links, and metadata. This clearly differentiates it from sibling tools like crypto_price or dune_query, which serve different purposes.

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

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

The description clearly implies when to use the tool (fetching public web pages) and adds cost per call, helping the agent decide on invocation. It does not mention exclusions or alternatives, but given the unrelated sibling tools, this is adequate 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 the full burden. It goes beyond a simple 'verify' by disclosing specific behavioral aspects: it performs live checks (whether the URL returns a 402, validates v2 JSON, etc.) and the cost of $0.02 per call. It doesn't mention response format or side effects, but still provides substantial behavior 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 exactly two sentences. The first front-loads the purpose, and the second lists the checks and cost. No redundancy or filler.

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

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

The description covers the core behavior and checks thoroughly. However, there is no output schema, and the description does not specify the exact return format of the 'conformance verdict' or handle error cases (e.g., unreachable URL). This is a minor gap for a tool with such a clear purpose.

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 both 'url' and 'method' having descriptions. The tool description does not add meaning beyond the schema; it only frames the URL as an x402-selling endpoint. This meets the baseline 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 a specific verb ('get a conformance verdict'), a resource (any URL that claims to sell over x402), and enumerates the exact checks performed. This distinguishes it from sibling tools like settlement_verify, which likely verifies settlements, and x402_receipt_lookup, which looks up receipts.

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

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

The description gives a clear trigger condition: use this when you encounter a URL that claims to be an x402 endpoint. It doesn't explicitly mention alternatives or exclusions, but the use case is well implied, making it clear when to invoke this tool.

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

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

With no annotations, the description carries the full burden. It discloses that the tool performs parallel live probes, names the specific endpoints, and even states the cost per call ($0.003/call). It doesn't describe return format or side effects, but for a read-only health check, the behavior is sufficiently 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 two sentences long, front-loaded with the primary purpose as a question, and then provides the key specifics (facilitators, probes, cost). Every word adds value, with no redundancy 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?

For a zero-parameter health check tool, the description is complete: it states what it does, what it checks, and the cost. It also differentiates from siblings by naming both production rails. The lack of output schema is acceptable since the purpose is straightforward and the agent can infer a status response.

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

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

The tool has zero parameters and the schema coverage is 100% (empty object). Since there are no param details to document, the baseline of 4 applies. The description adds contextual meaning by explaining what the tool actually checks, which is more valuable than parameter documentation.

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

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

The description clearly states the tool's purpose: checking if the x402 payment rail is up. It specifies the exact resources probed (Dexter facilitator and Coinbase CDP facilitator) and the attributes checked (supported kinds, schemes, networks, reachability, HTTP status, latency). This distinguishes it from sibling tools like x402_endpoint_verify, which likely targets a single endpoint.

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 opening question 'Is the x402 payment rail up right now?' establishes a clear use case for real-time health monitoring. It does not explicitly discuss alternatives or exclusions, but the specific mention of the two production rails implies when this tool is appropriate compared to more granular checks. This is clear context without explicit 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?

With no annotations, the description carries the full burden. It discloses the record fields (payer, payee, amount, status), the durable/on-chain nature, and the $0.002/call cost. It doesn't cover error cases or authentication, but for a read-only retrieval the key behavioral traits are present.

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

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

The description is two sentences, front-loaded with the action and resource, followed by a meaningful detail about the receipt contents and pricing. Every word earns its place with no redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is complete. It explains what the receipt contains, how it is identified, and its cost, covering the return value implicitly. No significant gaps remain.

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

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

Schema coverage is 100%: verification_id is already described as 'UUID returned by settlement_verify'. The description repeats 'by its verification_id' and adds the term 'durable record', but does not add new syntax or format details beyond what the schema already provides. Baseline 3 applies.

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

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

The description clearly states the verb 'Retrieve' and the resource 'stored settlement-verify receipt' keyed by verification_id. It explicitly contrasts with the sibling settlement_verify by positioning this as the retrieval of the durable record issued by that tool, making its unique role 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 when to use the tool: after calling settlement_verify, to fetch the stored receipt. It names the issuing tool and the lookup key, but it does not explicitly state when not to use it or name alternatives beyond the natural pairing with settlement_verify.

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