API Acre

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

Annotations indicate read-only, idempotent, non-destructive behavior. The description adds crucial behavioral details (robots.txt compliance, no JavaScript, no anti-bot bypass) and specifies the exact output structure, going well beyond the annotations.

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

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

The description is long due to listing output fields, but every sentence adds value and it is front-loaded with purpose. It is efficient with no fluff, though slightly verbose.

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

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

With a rich output schema and clear annotations, the description fully explains the tool's behavior, constraints, and parameter usage, making it complete for this moderately complex web-fetching 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 67%; the description clarifies the optional comparison via 'optionally compare the selected offer with a buyer-supplied maximum' for maximum_price, but does not mention expected_currency beyond its schema description. Baseline 3 is appropriate.

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

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

The description states a specific action ('Paste one public retailer product URL to get its current publisher-supplied structured price') with a clear resource and enumerates the exact data fields returned, distinguishing it from sibling tools focused on other domains.

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

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

It clearly states when the tool works ('Fetching proceeds only when robots.txt permits it') and its constraints (no JavaScript, login, etc.), implying appropriate usage contexts. It does not explicitly name alternative tools, but its domain is distinct.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral details beyond annotations, such as distinguishing checksum casing, identifying the zero address, and performing the operation without a network request. No contradictions with annotations.

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

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

The description is a single sentence that is front-loaded with the core action ('Validate and normalize') and packs all necessary details (ERC-55 checksum, zero address, no network request) without redundancy. Every phrase adds value; minimal waste.

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

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

For a tool with one parameter and an output schema (present), the description covers all essential aspects: input type, the operations performed, special cases (checksum casing, zero address), and a key behavioral constraint (no network request). The return format is presumably handled by the output schema, so the description is complete 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 schema has one parameter 'address' with only min/max length and no description (0% coverage). The description compensates by explaining that the address is an Ethereum/EVM wallet address and implying the expected format via checksum validation behavior. It doesn't give explicit format examples (e.g., 0x prefix), but it provides enough semantic context for an agent to understand the parameter purpose.

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: validate and normalize an Ethereum/EVM wallet address, distinguish valid/absent/invalid ERC-55 checksum casing, and identify the zero address. It uses specific verbs and resources, making it distinct from sibling tools like base-account-status or base-contract-inspect.

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 'without a network request' provides clear context for when to use this tool—offline address inspection. However, it does not explicitly mention alternatives or when-not-to-use, so it falls short of the highest bar but still offers useful usage context.

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

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

Annotations already establish read-only, non-destructive, idempotent behavior. The description adds valuable behavioral context by emphasizing 'point-in-time' and 'one resolved Base mainnet block,' indicating all reads are consistent at the same block. It also clarifies that native USDC and ETH are always included while other tokens are optional, which the annotations do not convey.

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

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

A single, concise sentence that front-loads the action ('Read') and packs in all essential details without redundancy. No filler words, and the structure is easy to parse.

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

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

The tool has a rich output schema, so return values need no explanation. The description covers the key behavioral aspects: what data is read (ETH, USDC, ERC-20s, nonce, code status), the block resolution semantics, and the optional token selection. It is complete for an agent to understand when and how to 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 100%, so baseline is 3. The description adds meaning by clarifying that ETH and native USDC are always included in the snapshot, while token_contracts is optional and limited to four ERC-20s. It also explains the significance of the block_tag as the resolved point-of-consistency, going beyond the schema field descriptions.

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

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

The description uses a specific verb 'Read' and identifies the exact resource: point-in-time ETH, native USDC, up to four caller-selected ERC-20 balances, account nonce, and contract-code status at one resolved Base mainnet block. This clearly distinguishes it from sibling tools like crypto.base-account-status, which likely provides a simpler current-state view.

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

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

The description conveys clear context: it is for reading a consistent snapshot at a chosen block, including token balances beyond the native asset. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full explicit exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds useful behavioral context: reads are performed at a single resolved block, and only 'official USDC' is considered, which goes beyond the annotations.

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

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

The description is a single, well-structured sentence with no superfluous words. It front-loads the main purpose and lists specific outputs efficiently.

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, the presence of a rich output schema, and strong annotations, this description covers all essential aspects. It explains what the tool does, what data it returns, and the consistency guarantee of a single resolved block.

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

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

Schema coverage is 100%, with both parameters clearly documented in the schema. The description's phrase 'single resolved block' echoes the schema's block_tag description but does not add new parameter-level information.

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

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

The description clearly states the tool checks a specific Base mainnet wallet or contract and lists the exact data returned: ETH and official USDC balances, transaction nonce, and contract-bytecode evidence. This specificity distinguishes it from generic siblings like crypto.base-account-snapshot.

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

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

The description implies usage when these specific account attributes (balances, nonce, bytecode) are needed, but it does not explicitly mention alternatives or provide when-not-to-use guidance. The sibling list includes similar tools, so more explicit differentiation would improve this dimension.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context by enumerating the exact return fields (header timestamp, transaction count, gas use, fees, roots, confirmations, head-distance evidence), which is not present in annotations.

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

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

A single, front-loaded sentence that efficiently communicates purpose, input methods, and return contents without redundancy. Every phrase contributes essential information.

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

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

With only two optional, well-documented parameters, annotations covering safety, and an output schema present, the description is complete. It additionally previews return fields, making the tool's behavior fully predictable for an agent.

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

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

Schema coverage is 100%, and both parameters have detailed descriptions including the precedence rule (block_number takes precedence over block_tag). The description does not add substantial meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get and inspect') and clearly names the resource ('one historical Base mainnet block'), with explicit input modes (exact number or latest/safe/finalized tag). It lists detailed output fields, distinguishing it from sibling tools focused on transactions, accounts, or network status.

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: block-level inspection by exact number or tag. It does not explicitly name alternatives or state when not to use it, but the tool's niche is evident from the resource and returned data, making the scope clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds behavioral context by noting that all reads occur 'at one resolved block,' which matches the block_tag schema and indicates consistent snapshot semantics. No annotation contradictions.

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, front-loaded sentence with the verb 'Inspect' immediately states the action. Every phrase contributes (chain, resource, specific inspection targets, block scope), with no filler or repetition.

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

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

Given the read-only annotations, a rich output schema, and full param schema coverage, the description adequately covers the tool's scope. It specifies all major inspection targets and the block resolution behavior, leaving no obvious gaps for an informed agent.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description's mention of 'one resolved block' reinforces the block_tag behavior but does not add new parameter details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Inspect') on a specific resource ('Base mainnet contract') and enumerates concrete data aspects: bytecode, token metadata, and ERC-165/721/1155 interface signals. This differentiates it from sibling tools like base-contract-read or base-block-inspect.

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 this tool (inspecting contract-level details at a specific block) but does not explicitly say when NOT to use it or mention alternative tools. It provides clear context of its purpose, so it meets the 'clear context, no exclusions' bar.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable context: 'bounded' (gas limit), 'resolved Base mainnet block' (block resolution once), 'retain call and block evidence' (evidence retention), and the limitation that only primitive ABI types are decodable. This goes beyond structured data.

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

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

One dense sentence that front-loads the core action ('Execute...') and packs in essential qualifiers ('bounded', 'read-only', 'resolved', 'retain evidence', 'optionally decode') without waste. Every 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?

Given the rich schema (6 params, output schema) and clear annotations, the description provides enough high-level context: it explains the tool's scope (single call), block resolution, evidence retention, and optional decoding. It does not elaborate on error handling or response structure, but those are covered by the output schema and specifications.

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

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

Schema coverage is 100% and each parameter has a detailed description (e.g., block_tag 'resolved once', gas_limit 'bounded', from_address 'no private key or transaction'). The main description does not add significant per-parameter meaning beyond these schema descriptions, so baseline 3 applies.

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

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

The description names a specific verb ('Execute') and resource ('read-only eth_call against a resolved Base mainnet block'), and clarifies scope with 'one bounded' and 'optionally decode caller-specified ABI output types'. This clearly distinguishes it from sibling tools like base-contract-inspect or base-event-logs.

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 (e.g., when a low-level contract read is needed) but does not explicitly state when to use this tool over alternatives or when not to use it. It provides no exclusion criteria or named sibling alternatives, so guidance is limited to what can be inferred from the stated 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?

Annotations already cover safety (read-only, idempotent, open-world, non-destructive), so the description adds value by specifying 'validated' events and a 'bounded resolved block range.' This provides useful behavioral context beyond the annotations, though it does not mention rate limits or other operational details.

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 verb and clearly conveys the tool's scope and constraints. Every word adds value with no redundant 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 moderate complexity, the presence of an output schema, rich parameter descriptions, and comprehensive annotations, the description sufficiently covers the core behavior and constraints. It appropriately communicates the single-contract scope and bounded block range, making the tool adequately understandable for an agent.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description summarizes the key parameters (event signature, topic filters, block range) but does not add new meaning beyond what is already in the schema, thus earning the baseline score.

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

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

The description clearly states it queries validated eth_getLogs events from one Base mainnet contract, with a specific verb, resource, and scope (required event signature, optional topic filters, bounded block range). This distinctly separates it from sibling tools like transaction inspection or contract reads.

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 identifies the tool's purpose: querying event logs from a single contract. While it does not explicitly name alternatives or when-not-to-use, the context is strong enough that an agent can infer when this tool is appropriate compared to other Base-specific tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds valuable behavioral context beyond these: 'preserve RPC rejection evidence', 'resolved block' (implying it resolves once), and 'bounded caller-selected buffer'. It also reiterates 'without signing or broadcasting' which is essential for safety understanding. No contradiction with annotations.

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

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

The description is a single sentence that is front-loaded with the primary action and packed with essential details. Every phrase adds value, with no filler or repetition of schema field names. It is concise yet comprehensive.

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 6 parameters, an output schema, and detailed annotations. The description covers the core behavior, safety guarantees, and key nuances (block resolution, buffer bounds, rejection evidence preservation). The output schema covers return values, so no need to duplicate. The description is complete for an agent to decide and invoke correctly.

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

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

Schema description coverage is 100%, so the description does not need to compensate. It does add high-level context for buffer_percent and block_tag ('bounded caller-selected buffer', 'resolved block') but does not explain individual parameters 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 the verb 'estimate gas' with the specific resource 'one Base mainnet transaction context'. It also includes key distinguishing details: 'at a resolved block', 'bounded caller-selected buffer', and 'preserve RPC rejection evidence without signing or broadcasting'. This distinguishes it from sibling tools like transaction-inspect or contract-read.

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 strong context: it's for estimating gas before sending a transaction, without signing or broadcasting. It implies usage when a gas estimate is needed with a buffer. It doesn't explicitly name alternatives or state when not to use it, but the purpose is narrow and clear enough for an agent to select it appropriately.

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

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

The description adds the behavioral detail of batching into a single RPC call and describes the fee history as bounded, which supplements annotations like readOnlyHint and idempotentHint. It does not contradict the annotations and provides performance-relevant context beyond the structured fields.

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

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

The entire description is one compact sentence of about 22 words, front-loaded with the core action ('Read the latest Base mainnet block') and includes no redundant words. Every part adds useful information.

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

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

Given that an output schema exists and both parameters are fully documented, the description is sufficient to understand the tool's purpose and expected output. It mentions the key data components (block, fee history, gas utilization, percentiles) and does not omit critical information for an agent deciding to call 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 input schema already provides complete descriptions for both parameters (fee_history_blocks and reward_percentiles), covering 100% of parameters. The description's mention of 'bounded' and 'priority-fee percentile samples' loosely maps to these parameters but does not add substantive meaning beyond the schema, so baseline 3 applies.

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

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

The description clearly states the tool reads the latest Base mainnet block and an EIP-1559 fee history in a single RPC batch, with specific data points like gas utilization and priority-fee percentiles. This verb+resource structure distinguishes it from sibling tools like crypto.base-block-inspect, which inspect individual blocks.

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

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

The description gives clear context for when to use the tool—to get a quick status snapshot of Base network's latest block and fee market in one call. However, it does not explicitly mention alternatives or exclusions, making it a 'clear context, no exclusions' case.

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

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

The annotations already mark this as a read-only, idempotent, non-destructive operation, so the description's main contribution is the detailed list of what the inspection returns, including 'bounded ERC-20-shaped transfers' and 'recognized calldata' — useful nuance. No behaviors beyond the annotations are promised, and nothing contradicts the annotations.

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

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

The entire description is one dense sentence that packs in all key details without redundancy. Every phrase adds value, and it is appropriately front-loaded with the core action.

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 single-parameter read-only tool with a rich output schema, so the description needs only to explain the tool's scope and key outputs, which it does thoroughly. The inclusion of USDC recognition and bounded transfers gives an agent enough context to decide when to call it.

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

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

The schema already fully documents the single transaction_hash parameter with a clear description and example, achieving 100% coverage. The tool description adds no additional meaning about the parameter itself, so the baseline of 3 applies.

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

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

The description opens with a specific verb 'Inspect' targeting 'Base transaction status and receipt evidence', clearly differentiating from sibling tools like base-block-inspect or base-account-status. It enumerates concrete output facets (success/revert/pending, confirmations, gas fees, calldata, ERC-20 transfers, USDC recognition), making the tool's purpose unambiguous.

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

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

The description implies usage for anyone needing transaction-level details in a single call, but it never explicitly contrasts it with sibling tools or states when not to use it. Sibling names like crypto.base-block-inspect suggest alternative scopes, but no direct guidance is provided, leaving the agent to infer from the name.

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

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

Annotations already declare read-only, non-destructive, idempotent behavior. The description adds useful context beyond annotations: 'validated, bounded block range' and 'newest-first' ordering. It does not over-explain or contradict the annotations, and the safety profile is well-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 a single, dense sentence that front-loads the core purpose and key constraints. Every word contributes to understanding what the tool does without 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?

The tool is moderately complex with 5 parameters, but the schema and annotations provide full parameter details and safety context. The description adds the essential behavioral context (ordering, bounded range) and an output schema exists, so the agent has enough information to select and invoke this tool correctly without needing further explanation.

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 provides 100% parameter description coverage with details on defaults, bounds, and enums. The description itself adds no additional parameter-level meaning, but the schema is sufficient, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Retrieve' and clearly identifies the resource: Circle USDC Transfer events for one address. It also specifies ordering ('newest-first'), direction ('incoming and outgoing'), and scope ('validated, bounded Base mainnet block range'), which distinguishes it from generic blockchain tools like crypto.base-event-logs.

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 querying USDC transfers on Base mainnet but provides no explicit alternatives or when-not-to-use guidance. It does not mention sibling tools or exclusion criteria, so the agent must infer the appropriate context from the tool name and 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds valuable behavioral context beyond annotations, such as 'without a network lookup' (offline operation) and 'strictly decode' (strictness), plus the bounded selector set. This enriches the agent's understanding of the tool's behavior.

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

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

The description is a single, compact sentence that front-loads the main actions and avoids redundancy. It is slightly dense due to the compound structure, but every 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?

With a rich output schema and fully described parameters, the description covers the essential operational modes and the offline property. Nothing critical appears missing; the combination of description and schema gives a complete picture 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?

Schema description coverage is 100%, so baseline is 3. The description adds conceptual framing by relating the two modes—resolving built-in selectors vs. using a supplied signature—to the parameters. This helps an agent understand how calldata, input_mode, and function_signature interact, going beyond individual schema descriptions.

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

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

The description clearly states a specific verb+resource: it resolves 29 common ERC selectors or decodes arbitrary EVM calldata. This distinguishes it from siblings like crypto.typed-data-hash, and the two modes are explicitly named.

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 explicitly mention alternatives or exclusions, but the tool's scope is self-evident: it is for decoding calldata or resolving standard selectors. The schema's input_mode and function_signature descriptions provide additional usage context, making the intended use clear.

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

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

Annotations already cover read-only and idempotent behavior, so the description doesn't need to repeat that. It adds the behavioral detail that the tool validates and derives three specific outputs. However, it doesn't mention error behavior on invalid data or whether network access is required, which would be useful context beyond the annotations.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently conveys the action, the target, and the outputs.

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 complex EIP-712 tool, the description covers the essential purpose and outputs. An output schema exists to handle return details, so the description need not explain the full return structure. It could mention validation failure behavior or the context of signing, but overall it is sufficiently complete given the annotations and schema.

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

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

The schema has zero description coverage, so the description must compensate. It identifies the input as 'EIP-712 typed structured data', which adds a bit of meaning over the schema's generic 'Typed Data' label. But it doesn't specify the required object shape (e.g., types, primaryType, domain, message). With only one param, the hint is minimal but adequate for an agent to make a reasonable guess.

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 ('Validate', 'derive') and clearly identifies the resource ('EIP-712 typed structured data') and the distinct outputs (domain separator, message hash, signing digest). This strongly distinguishes it from sibling tools like crypto.calldata-decode.

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

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

The description implies the tool is for EIP-712 typed data hashing/validation but does not explicitly state when to use it vs alternatives or provide any exclusion criteria. There is no mention of related tools or scenarios where a different tool would be more 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds specific behavioral details beyond the annotations, such as collision-safe header normalization, deterministic integrity hashes, and exact transformation counts, giving agents a clearer picture of what the operation does and returns. No contradiction with annotations.

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

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

The description is a single sentence that front-loads the core purpose and lists supported formats and key features without redundancy. It is dense but not bloated; a slight structural breakdown could improve scannability, but it remains concise and effective.

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

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

The output schema exists, so the description does not need to explain return values. It covers supported formats and the main transformation behaviors, while the schema handles limits like maxLength and the enum for format. The main gap is insufficient explanation of parameter semantics, but this is partly mitigated by the output schema and self-explanatory parameter names.

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 only 20% (only 'format' is described). The description mentions 'collision-safe header normalization,' which partially explains normalize_headers, but trim_strings and empty_to_null are left entirely to their names. There is no clarification of how empty strings become null or how trimming behavior works, so parameter semantics remain under-specified.

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 the specific verb 'clean' with a clear resource (CSV/TSV/JSON/JSONL/YAML records) and elaborates on what cleaning entails: collision-safe header normalization, deterministic integrity hashes, and exact transformation counts. This distinguishes it from sibling tools like data.convert and data.deduplicate, which have 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?

No explicit when-to-use or alternative guidance is provided. The intent is implied by the purpose, suggesting use when records need standardization or transformation metrics, but it does not mention when not to use it or how it compares to closely related tools such as data.deduplicate or data.json-repair.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false; the description adds context by specifying deterministic JSON, the exact schema version, and the single-call pipeline. It does not contradict the annotations, and it clarifies the operation is non-mutating and repeatable.

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 sentence that front-loads the primary action and keeps all details necessary. It avoids filler and each clause adds distinct information.

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

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

For a three-stage tool, the description explains the pipeline at a high level, and the output schema covers return details. It does not discuss failure modes or the effect of root_mode/max_errors, but those are partially described in the input schema, making this adequate but not exhaustive.

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

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

The schema covers 67% of parameters with descriptions (format, instance, root_mode, check_formats), and the description complements them by linking format/content to the normalization step. However, content and max_errors remain without extra explanation, and the description doesn't add syntax or edge-case details beyond the schema.

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

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

The description uses specific verbs (normalize, infer, validate) and names concrete formats (CSV, TSV, JSON, JSON Lines, YAML) plus a schema version (Draft 2020-12). It clearly distinguishes this from sibling data tools by framing a combined pipeline, with 'validate one future JSON value' as the unique deliverable.

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 a use case (processing structured data into a contract and checking a future value) but does not explicitly state when to prefer this over data.convert, data.schema, or data.schema-validate, nor does it mention exclusions. Without explicit alternatives or when-not-to-use, guidance remains only implied.

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

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

Annotations already mark the tool as read-only and idempotent. The description adds behavioral details: deterministic integrity hashes, JSON-encoded nested tabular cells, and explicit rejection of ambiguous duplicate keys or non-finite numbers. These go beyond safety annotations and align with the declared non-destructive nature.

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 front-loads the action and formats. It packs many behavioral specifics but remains readable; no unnecessary words, though it could be broken into two sentences for readability.

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

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

With an output schema present, the description covers the main conversion behavior, input formats, and edge-case handling. It omits only secondary details like the content length cap, which is in the schema. For a 4-parameter tool with rich annotations, this 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?

Schema description coverage is 75% (format, root_mode, and target_format are documented; content lacks a description). The description adds context on root_mode's 'preserve' behavior and format restrictions, but does not compensate for the undocumented content parameter or add syntax-level detail beyond the schema.

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

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

The description uses the specific verb 'Convert' and enumerates the exact formats (CSV, TSV, JSON, JSON Lines/NDJSON, YAML), plus optional root preservation and rejection of ambiguous input. This clearly differentiates it from sibling data tools like data.json-repair or data.clean.

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 format conversion but does not explicitly state when to prefer it over alternatives or mention exclusions, such as when to use data.json-repair for malformed input. No alternatives are named, so guidance is only implicit.

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

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

Annotations already declare read-only and idempotent behavior, and the description adds substantial context: fallback from NOAA/NWS observation to MET Norway model, explicit labeling of observation vs model, bounded SI fields, and source provenance. This goes well beyond the safety hints.

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

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

Two compact sentences front-load the core purpose and then supply essential data-source details. No filler, no repetition of schema content, every sentence earns its place.

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

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

With an output schema present, the description does not need to detail return fields. It covers source selection, fallback behavior, labeling, unit constraints, and provenance—sufficient for an agent to invoke correctly across the oneOf parameter patterns.

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

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

Schema coverage is 100% and each parameter already has rich descriptions including examples and constraints. The tool description repeats the city-or-coordinates alternative but adds no new parameter-level meaning beyond what the schema 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 the tool gets one current weather snapshot for a city/locality or coordinates, immediately distinguishing it from sibling data.us-weather-forecast (forecast vs current) and geocoding tools. The verb 'Get' is specific and the resource is precisely scoped with data-source context.

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 (current weather vs forecast) but does not explicitly name alternatives or state when not to use it. The city-or-coordinates disambiguation is implied through the schema rather than directly spelled out in usage terms.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context: dedup based on identity fields and reporting the removed count. It does not discuss permissions or edge cases, but given the annotation coverage, 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 one sentence, front-loaded with the verb 'Remove', enumerates the formats, and states the core behavior and output. Every word earns its place 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?

An output schema exists (per context signals), so the return value details are presumably already available. The description covers purpose, formats, identity fields, and the removed-count aspect. It lacks edge-case behavior such as handling of missing keys or default key selection, but for a tool of this complexity, it is largely complete.

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

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

Schema description coverage is only 25% (only format has a description). The description partially compensates by clarifying that keys represent 'selected identity fields' and by listing supported formats. However, it leaves the `keep` parameter (first/last) undocumented in both schema and description, and `content` is only obvious from its name, creating a gap in 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 the tool removes duplicate records across five formats using identity fields and reports the removed count. The verb 'remove' plus resource 'duplicate records' and scope (formats/identity fields) makes the purpose unambiguous and distinguishes it from siblings like data.clean or data.convert.

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 deduplication but provides no explicit guidance on when to choose this over related data tools or mention exclusions/alternatives. The mention of identity fields and formats gives context, but it stops at implied usage rather than offering clear when-to-use vs. 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds valuable context beyond annotations: bounded retrieval, validation, clearly labelled cross-rate calculation, and x402 delivery with a fee. This meaningfully informs the agent about what happens during invocation.

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 tightly written sentences: the first nails the core function, the second adds relevant commercial/sourcing context. Every phrase 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?

Given the rich input schema, enums, output schema, and detailed annotations, the description is sufficient. It adds the key non-schema context (data source, fee, delivery mechanism, validation). It does not explicitly mention the optional date parameter, but the schema already covers that thoroughly.

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

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

Schema description coverage is 100%, so the schema already documents amount, currencies, and date semantics. The description adds only general context ('supported currencies', 'amount') but no parameter-level detail beyond what the schema provides, which matches the baseline for high schema coverage.

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

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

The description clearly states the action ('Convert an amount'), the specific resource ('ECB daily reference-rate observation'), and the scope ('between two supported currencies'). This distinguishes it from generic converters like data.convert and other sibling tools.

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

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

The description makes the tool's purpose clear and implies its use for ECB-reference-based currency conversion, but it does not explicitly state when to prefer this over alternatives or provide exclusions. The context is clear, yet no alternatives or when-not-to-use guidance is offered.

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

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

Annotations already declare read-only, idempotent, non-destructive. The description adds valuable behavior context: transformation hashes, strict rejection of duplicate keys or non-finite numbers, and 'safely' removing. No contradiction with annotations.

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

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

A single dense sentence front-loaded with the core action. Each clause adds unique information, making it compact yet comprehensive. Slightly long but appropriate for the complexity of the tool.

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

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

The description covers repair types and rejection constraints, but leaves open questions about default repairs when the optional `repairs` array is omitted and behavior for already-valid JSON. Output schema likely explains return values, so this is sufficient but not exhaustive.

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% (only `repairs` has a description). The tool description enumerates repair classes that map directly to the `repairs` enum and clarifies `content` as caller-supplied JSON. However, it does not explain default behavior when `repairs` is omitted or how transformation hashes appear in output, leaving gaps.

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 repairs malformed JSON, enumerating specific operations (outer Markdown fence, comments, single-quoted strings, unquoted keys, Python literals, trailing commas) and constraints (transformation hashes, strict rejection of duplicate keys/non-finite numbers). This distinguishes it from generic data.clean or data.convert 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?

Provides clear context: use for caller-supplied malformed JSON. It does not explicitly name alternatives (e.g., data.schema-validate for validation, data.clean for general cleaning) or state when not to use, but the specific repair scope implies the intended use case.

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

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

Annotations already mark the tool as readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by revealing that no request-time network call is needed (suggesting cached or offline data) and that results are 'population-ranked' and 'bounded'. This discloses behavioral traits beyond what annotations provide, making the tool's operational context clearer.

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 significant detail (input, output fields, ordering, no network call) without being overly verbose. It is well front-loaded with the main action. However, it could be slightly more structured by splitting into smaller sentences for readability, but overall it is efficient and 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 presence of an output schema and rich annotations, the description provides a good overview of the tool's inputs, outputs, and key behavioral traits. Minor missing detail: it does not mention that the tool returns multiple candidates (implied by 'population-ranked' but not explicit). However, the limit parameter in the schema covers this, so the description is sufficiently complete for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add any additional meaning beyond the schema; it only mentions the input is a 'city or locality name' but does not describe the 'limit' parameter or provide further semantics. The schema itself already describes both parameters well, so the description adds no extra value for 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 the tool resolves a global city or locality name into detailed geographic data (coordinates, country, region, population, timezone, etc.). It uses a specific verb ('resolve') and resource ('city or locality name'), and distinguishes itself from sibling tools like data.us-address-geocode by specifying 'global' and 'without a request-time network call'.

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

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

The description implies the tool is for global city/locality names but does not explicitly state when to use it over alternatives. It lacks clear 'when to use' or 'when not to use' guidance. The schema parameter description for 'place' provides a limitation (not for street addresses), but the tool description itself offers no usage direction, leaving the agent to infer context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds clarity about what the tool produces (field types, nulls, uniqueness, samples), which is useful behavioral context beyond the annotations.

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

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

One sentence, 15 words, front-loaded with the verb and resource. 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 simple read-only profiling tool with good annotations and an output schema, the description is sufficient. It would benefit from noting any sampling limits or behavior with malformed input, but it's broadly complete.

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

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

Schema coverage is 50% (format is described; content is not). The description implicitly covers the format parameter by listing supported formats, but gives no additional detail about content (e.g., how to provide data or limits beyond schema maxLength).

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 ('Profile') and clearly identifies the resource (CSV, TSV, JSON, JSON Lines, YAML records) and the outputs (field types, nulls, uniqueness, representative samples). It distinguishes itself from sibling tools like data.schema (schema inference) and data.clean (cleaning).

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 it should be used when you need to understand the structure and quality of tabular or JSON data. It does not explicitly mention alternatives or exclusions, but the purpose is clear enough 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?

The description clearly adds behavioral context beyond annotations: the tool operates offline ('without a request-time network call'), uses 'great-circle-distance-ranked' ordering, and returns specific data fields. Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as true/false, so the safety profile is covered. The description further explains the offline behavior, which is a key 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 a single sentence that packs significant detail (operation, input, output fields, constraints, offline nature). It is front-loaded with the core action. No waste. However, it is dense and could benefit from a slight structural break (e.g., a second sentence for when to use) for readability, but it remains 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?

Given the tool has 4 parameters (all documented in schema), an output schema (so return structure is not needed in description), and full annotation coverage, the description is nearly complete. It explains the offline nature and ranking, which are critical for correct use. The only minor gap is not explicitly stating that results exclude the input point itself (if applicable) or handling of edge cases (e.g., no places within radius).

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 does not add extra semantics for individual parameters (like formatting constraints or data source details) beyond what the schema already provides (bounds, defaults, examples). It does imply the parameters collectively define a geocoding query, but that is already clear from the tool purpose.

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 exactly what the tool does: 'Resolve one latitude/longitude pair into bounded, great-circle-distance-ranked nearby GeoNames populated places with country, first-level region, population, timezone, feature code, and source freshness'. It clearly distinguishes from siblings like data.place-geocode (forward geocoding) and data.us-address-geocode (US-specific address geocoding), using specific verb 'resolve' and resource 'nearby GeoNames populated places'.

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 offline geocoding by mentioning 'without a request-time network call', which hints at when to use this over network-dependent alternatives. However, it lacks explicit guidance on when not to use it or alternatives for reverse geocoding with different data sources (e.g., OpenStreetMap or custom datasets). The sibling tools include forward geocoding tools, so exclusion is implicit but not stated.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context: it explains that bounds are non-enforcing, that CSV/TSV numeric and null inference is equivalent, and that the result is a contract. This goes beyond the annotations without contradicting them.

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

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

The description is a single sentence but not excessively long; it packs many relevant specifics. The opening 'Create and generate' is slightly redundant, and the long tail of modifiers is a bit dense, yet every clause adds meaningful information without being bloated.

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 and the presence of an output schema, the description covers input formats, inference behavior, and bound semantics. It is adequate for an agent to decide when to invoke it, with minor gaps like error handling or size limits that are implied by the schema and annotations.

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 67% (format and root_mode are described). The tool description reiterates the format options and mentions inference but adds little detail about the 'content' parameter or parameter-specific semantics beyond what the schema already provides. The baseline of 3 is appropriate.

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

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

The description provides a specific verb ('Create and generate') and a specific resource ('JSON Schema Draft 2020-12 contract'), and explains the inference method and supported input formats. This clearly distinguishes the tool from siblings like data.schema-validate (which validates) and data.profile (which profiles).

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 the tool is for generating a schema from representative records and lists the input formats. However, it does not explicitly name alternatives or state when not to use it, though the context is clear enough 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?

The description adds valuable behavioral context beyond annotations: deterministic output (matching idempotentHint), privacy scrubbing, and field-level evidence hashes. These traits are not stated in the annotations, enriching the agent's understanding of the tool's behavior.

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

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

The entire description is a single, dense sentence that front-loads the action and key output characteristics. Every phrase adds information (input format, output types, deterministic, privacy, hashes) with no redundant words.

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

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

Given the rich annotations and output schema, the description covers most essentials—input, output entity types, determinism, privacy, and hashes. The main gap is explaining the role of base_url and the exact processing of 'inline' JSON-LD, but overall it is sufficiently complete for a tool with strong structured metadata.

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

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

With schema description coverage at 0%, the description must compensate. It maps 'caller-supplied inline Schema.org JSON-LD' to the html parameter and lists entity types matching include_types, but base_url is entirely unexplained. Thus it adds partial meaning but leaves a gap for one 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 normalizes caller-supplied Schema.org JSON-LD into specific entity types (Organization, Product, etc.) with added privacy scrubbing and evidence hashes. It uses a specific verb (normalize) and resource, making it distinct from sibling tools like data.schema-validate.

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 indicates the input (inline Schema.org JSON-LD) and output (normalized entities), establishing when to use this tool for normalization tasks. However, it does not explicitly mention alternatives or exclude use cases, so while clear, it lacks explicit differentiation from related schema tools.

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

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

Annotations already provide read-only, idempotent, non-destructive hints. The description adds valuable context beyond annotations: deterministic JSON Pointers, explicit error truncation, input hashes, and no remote reference resolution. These details align with and enrich the annotation profile, making the tool's behavior transparent.

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

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

The description is a single dense sentence that front-loads the core purpose and then lists specific behaviors. It is informative without excessive verbosity, though it could be slightly more structured (e.g., splitting into two sentences) to improve readability. Every clause contributes value, so it earns a high score.

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

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

Given the tool's moderate complexity (4 params, output schema present, nested objects), the description covers essential aspects: purpose, constraints (bounded, no remote refs), and return characteristics (pointers, truncation, hashes). The presence of an output schema relieves the description from detailing return types, and it provides enough context for an AI agent to use 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?

With high schema description coverage (75%), the baseline is 3. The description does not add parameter-specific meaning; it focuses on overall behavior. The schema already describes `schema` and `check_formats` well, but `instance` and `max_errors` rely on types and defaults, which the description does not elaborate on. It neither compensates for gaps nor adds extra insight.

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 action ('Validate') with a well-defined resource ('JSON data') and scope ('bounded JSON Schema Draft 2020-12 contract'), and it enumerates supported keywords. It differentiates from sibling tools like data.schema by focusing on validation rather than schema definition or other data operations.

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 (validating JSON against a schema) and hints at limitations ('bounded', 'no remote reference resolution'), but it does not explicitly mention alternative tools or when not to use it. The guidance is primarily inferable from the capabilities listed rather than direct comparison with siblings.

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

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

The description adds significant behavioral context beyond the annotations: explicit handling of DST gaps and repeated hours, provision of nearby transition evidence, and use of a pinned local time-zone database. Annotations (readOnlyHint, idempotentHint) are consistent, and no contradictions 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?

The description is a single sentence that densely packs key features. It is front-loaded with the core action 'Convert... between IANA time zones'. While effective, it could be slightly more readable if split into two sentences, but remains concise.

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

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

Given the tool's complexity (5 params, output schema present), the description covers core functionality, special DST handling, and database source. With an output schema, return values need not be explained. A small gap: no mention of required input format constraints beyond schema examples, but overall 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?

Schema description coverage is 100%, so the baseline is 3. The tool description does not add extra parameter-level semantics beyond what the schema already provides (clear descriptions for all 5 parameters).

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

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

The description clearly identifies the tool's function: converting timestamps between IANA time zones, with specific details about handling DST gaps and repeated hours. It distinguishes itself from generic conversion tools like data.convert, and is unique among siblings.

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

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

The description implies usage for timezone conversion but does not explicitly state when to use this tool versus alternatives (e.g., data.convert). No exclusions or when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and no destructiveness. The description adds value by specifying the output coordinate system (Census MAF/TIGER), optional bounded geography fields, exact source attribution, and range-interpolation limits. This provides behavioral context beyond the safety profile set by annotations.

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

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

The description is a single sentence that delivers maximum signal in minimum space. It front-loads the core action and then lists all key features without any filler or repetition.

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

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

For a tool with an output schema and comprehensive annotations, the description covers the essential aspects: scope, output type, optional geographies, source attribution, and interpolation limits. The only minor omission is the explicit data source (Census Geocoder API), but that is disclosed in the parameter description. Overall, the description is fully adequate.

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

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

Schema coverage is 100% with clear parameter descriptions for both 'address' and 'include_geographies'. The main description adds no additional parameter details beyond the schema. Per rules, baseline 3 is appropriate when the schema already does the heavy lifting.

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

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

The description uses the specific verb 'Geocode' paired with a precise resource (structural address in US, Puerto Rico, or US Island Areas), and enumerates distinct output features (Census MAF/TIGER coordinates, optional geographies, source attribution, interpolation limits). No sibling tool performs geocoding, so it is easily distinguished.

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 geographic scope and that it handles a single structural address, which tells the agent when to use the tool. However, it does not explicitly state when not to use it or name alternative tools, though no sibling geocoding tool exists to cause confusion.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful source-selection behavior: NOAA/NWS preferred for U.S. coverage, MET Norway attributed fallback globally, and optional inclusion of station conditions and active alerts. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that conveys the core purpose, the dual input modes, the output period types, and the source strategy without wasted verbiage. Every 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 moderately complex tool with 10 parameters and an output schema, the description covers the key decision-relevant context: global scope, forecast period kinds, source precedence, and optional alert/condition augmentation. The schema handles remaining details like the oneOf constraint and exact parameter bounds, so the description does not need to repeat them.

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 detailed per-parameter descriptions for place, coordinates, units, periods, timezone, forecast type, source preference, and alerts. The description adds a high-level summary of accepted inputs (place vs coordinates) but does not materially augment the schema's 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 opens with 'Get a global weather forecast for a city/locality name or exact coordinates', clearly stating the verb, resource, and input modes. It further distinguishes the tool by specifying normalized day/night or hourly periods and the dual-source NWS/MET-only behavior.

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 is clear: this is a global weather forecast tool with NWS preferred in U.S. areas and MET Norway fallback. However, there is no explicit mention of when to prefer this tool over the sibling data.current-weather tool or other weather-related alternatives, so usage 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?

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context about official source evidence and explicit missing-data semantics, going beyond the annotation basics. It does not detail error handling or rate limits but provides meaningful behavioral disclosure.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then lists output fields. Every element adds value 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?

Given the presence of an output schema and rich annotations, the description covers purpose, scope, and key behavioral details (source evidence, missing-data semantics). It is complete enough for an agent to select and invoke the tool correctly, though it does not cover edge cases like API availability or rate limits.

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 both parameters (vin and model_year), so the schema fully explains them. The description does not add extra parameter-level meaning; the mention of missing-data semantics refers to output, not parameter usage. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Decode') and identifies the exact resource ('full 17-character VIN') and outputs (make, model, year, body, engine, etc.). It clearly distinguishes this tool from any sibling by its unique domain and specificity.

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

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

The description implies usage for VIN decoding and explicitly restricts to full 17-character VINs, ruling out partial VINs. It does not name alternatives, but among the large sibling list none address VIN decoding, so the context is clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, which cover safety and side effects. The description adds meaningful behavioral context: it bundles multiple indicators into one snapshot, includes both latest and previous values, and provides source and license evidence. This goes beyond the annotations by explaining what the output contains. No contradictions with annotations.

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

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

The description is a single sentence that packs a lot of information: the exact indicators, the normalization, the temporal scope (latest and previous), and evidence inclusion. It is concise and front-loaded, but it is somewhat long and could be broken into two sentences for clarity. Still, every phrase adds value, so a 4 is appropriate.

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

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

Given the tool has an output schema (though not shown), annotations that establish read-only/open/idempotent behavior, and a clear parameter list, the description is largely complete. It explains what data is bundled and that evidence is attached. It could specify whether 'previous' means one year prior or multiple, but the lookback_years parameter implies configurability. The coverage is sufficient for an AI agent to understand the tool's purpose and expected output.

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

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

Schema description coverage is 100%: both country_code and lookback_years have descriptions. The description adds minimal extra meaning beyond the schema, but it does clarify that lookback_years is the 'calendar-year window to request for every fixed indicator', which aligns with the schema's description. The description names the bundled indicators, giving context that country_code refers to the country for which these indicators are fetched. Baseline 3 is appropriate since schema covers parameter semantics adequately.

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 bundles six official World Development Indicators into a normalized country snapshot, specifying exact indicators (GDP, growth, population, inflation, unemployment, life-expectancy) and that it includes latest/previous observations plus source/license evidence. It distinguishes itself from generic data tools like data.clean or data.profile by focusing on World Bank development data retrieval.

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 obtaining a comprehensive country-level economic snapshot with a single call, and mentions 'latest and previous' observations, implying time-series context. It does not explicitly name alternative tools or state when not to use it, but given the sibling list includes data.clean and data.profile for other data operations, the intended use case is clear enough. No exclusions or alternatives are stated, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by explicitly stating no execution or network access and describing what analysis is performed. It does not contradict annotations and adds supplementary detail beyond the structured hints.

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

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

The entire description is one focused sentence. It front-loads the core action and constraints, then lists specific outputs without padding. Every phrase contributes meaningful 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 output schema exists, the description does not need to explain return values. It covers the core inputs, the static nature of the operation, and the major output categories. It lacks detail about language/filename parameters and edge-case limitations, but remains largely complete for this tool's 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. It clarifies that before/after are source snapshots, but it does not explain the filename or language parameters, their defaults, or their impact. Two of four parameters remain underspecified.

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 starts with a specific verb ('Compare') and identifies the resource (caller-supplied before/after source snapshots) and scope (without execution or network access). It lists concrete outputs (source fingerprints, syntax regressions, structural deltas, function-level changes, bounded review findings), which clearly distinguishes it from sibling tools like developer.structured-diff and developer.code-metrics.

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: this is a static, non-executing, offline comparison of source snapshots, which implies when to use it (safe code review). It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds 'without retaining or forwarding the code' (privacy guarantee) and clarifies the trial/payment model (bounded no-wallet trial via separate endpoint; paid MCP call). No contradiction with annotations.

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

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

Two sentences: the first packs the main functionality and outputs; the second handles trial/payment info. Front-loaded and waste-free, though dense. Length is appropriate for the tool's complexity.

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

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

With an output schema present, return-value documentation is covered. However, missing parameter semantics and usage guidelines leave gaps. The description covers purpose, behavior, privacy, and payment well, but for a tool with 2 params and 0% schema coverage, it could be more 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 has 0% description coverage, so the description must compensate. It references 'caller-supplied source code' for the `code` param but never explains the `language` parameter (default 'text', max length 40). No details on acceptable languages, format, or why `code` has a 2MB limit. This is a significant gap.

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 opens with 'Measure caller-supplied source code' – a specific verb and resource. It lists concrete outputs (per-function complexity, SHA-256 fingerprint, density ratios, syntax status, maintainability signals), making the tool's purpose clear and distinguishing it from sibling developer tools like code-change-review or dependency-audit.

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

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

No explicit usage conditions or alternative tools are mentioned. The description implies use for code metrics but doesn't state when to choose this over related tools (e.g., developer.code-change-review). No when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context by specifying that it audits 'exact' dependencies and returns affected packages and vulnerabilities, which goes beyond the annotation safety profile.

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 action and resource, with no redundant words. The enumeration of ecosystems is necessary for clarity and does not feel excessive.

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

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

Given the presence of annotations and an output schema, the description is complete enough: it clearly states the purpose, target ecosystems, and the return type. It does not mention input limits or exact version formatting, but those are covered by the input schema.

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

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

Schema description coverage is 0%, but the description enumerates the supported ecosystems (matching the schema enum), providing some semantic value. However, it does not explain the dependencies array structure (name/version) or constraints like max 100 items, leaving that to the schema.

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

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

The description uses a specific verb ('Audit') with a clear resource ('dependencies') and scope ('against OSV'), and states the result ('return affected packages and vulnerabilities'). It clearly distinguishes from sibling tools like license-audit by focusing on vulnerability auditing across multiple ecosystems.

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 (auditing dependencies for known vulnerabilities) but does not explicitly state when not to use or reference alternatives. It lacks exclusions or a comparison with sibling audit tools, leaving the agent to infer usage from context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the tool's core behavior (classifying licenses, flagging review) but does not disclose additional behavioral details such as how the policy parameter affects classification, what data sources are used, or any edge cases. With annotations present, 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 a single, front-loaded sentence with no filler. It captures the essential purpose and output intent efficiently.

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

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

Despite having an output schema, annotations, and a moderately simple input schema, the description omits critical information about the 'policy' parameter, which is central to the tool's behavior. It does not clarify what 'commercial' vs 'permissive' means or how it influences the flagging. The tool is simple but the missing policy explanation makes the description incomplete for effective 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 0%, so the description carries the full burden for explaining parameters. It does not mention 'policy' or explain its enum values ('permissive' vs 'commercial'), nor does it detail the structure of the 'dependencies' array beyond implying the domain. The description adds minimal meaning to the parameters, leaving the policy semantics entirely unexplained.

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: 'Classify software dependency licenses and flag packages that need commercial or legal review.' It uses specific verbs ('classify', 'flag') and identifies the resource (software dependency licenses). This distinguishes it from the sibling tool 'developer.dependency-audit', which likely handles broader dependency auditing, by focusing on license compliance.

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 a clear use case: when you need to classify dependency licenses and identify packages needing review. It provides context but does not explicitly exclude alternatives or name the sibling 'developer.dependency-audit' as the alternative for broader audits. Thus, it has clear context but lacks explicit when/when-not guidance.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds the audit scope but does not detail what happens during execution (e.g., parse errors, limit behavior). No contradiction with annotations.

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

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

The description is a single sentence, directly front-loaded with the core purpose, and every word adds value. 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 tool has moderate complexity given the output schema and annotations, but the description does not address edge cases or clarify what 'consistency problems' encompasses. Parameter semantics are also absent, leaving the overall context somewhat incomplete.

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

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

Schema has 0% description coverage, and the description does not explain the 'document' or 'format' parameters. While the parameter names and enum hint at their role, the description fails to clarify expected formats or that 'document' is likely an inline string, leaving ambiguity.

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 validates and audits OpenAPI documents, listing specific checks (operation IDs, descriptions, responses, consistency). This distinguishes it from sibling tools like openapi-test-generate and data.schema-validate.

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 auditing OpenAPI documents but does not explicitly state when to use this over alternatives or provide exclusions. No mention of sibling tools or conditions that make this tool preferable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by explaining that output is deterministic, syntax-validated, and that mutating operations are disabled by default. This goes beyond the annotations without contradicting them.

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

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

The description is a single, well-structured sentence that front-loads the core action and includes only value-adding qualifiers. No redundant or filler 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 description provides a clear overview but is insufficiently detailed for an 8-parameter tool. It omits how parameters like auth environment variables, timeouts, and limits affect test generation. The output schema likely covers return values, but the description still leaves gaps in operational context.

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

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

With 8 parameters and zero schema description coverage, the description should compensate but only indirectly references the 'document' parameter through 'caller-supplied OpenAPI 3 document.' The other parameters (format, base_url, api_key_env, bearer_token_env, etc.) are left undefined, and the schema titles/defaults do not fully clarify their 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 uses a specific verb ('Generate') and specifies the exact resource ('pytest and requests smoke tests') and source ('caller-supplied OpenAPI 3 document'). It also includes distinctive qualifiers ('deterministic, syntax-validated') and clearly distinguishes this tool from sibling tools like openapi-audit.

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

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

The description implies the use case: generating smoke tests from an OpenAPI document when deterministic, validated tests are needed. It does not explicitly mention alternatives or exclusions, but the context is clear enough given that sibling tools like openapi-audit serve a different 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?

Annotations already declare read-only, non-destructive, idempotent. The description adds 'no network access or code execution' and 'fully redacted preview', which are safety and output-behavior disclosures beyond the annotations, enhancing 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?

Two succinct sentences: first defines the tool's purpose and scope, second outlines return values and safety. No redundant phrasing, perfectly front-loaded.

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

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

The tool has an output schema (not shown), so detailed return values are not needed. The description covers the key behavior, safety, and input type. It lacks explicit limitations (e.g., false-positive rates) but remains sufficient for straightforward 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 0%, so the description must clarify the single parameter. It states 'caller-supplied source or configuration text', which conveys what to pass, but adds no format examples or edge-case guidance. This is adequate but minimal.

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 detects likely leaked secrets (API keys, tokens, etc.) in caller-supplied text, listing specific secret types and the output details (type, line, fingerprint, redacted preview). This strongly differentiates it from sibling tools like document.redact or data.clean.

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

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

The description implies usage when scanning source/config text for secrets but does not explicitly mention alternatives or when-not to use. The specific scope ('caller-supplied source or configuration text') provides context, but exclusions are absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable context: it operates without a database connection or execution, and it specifically flags destructive DDL, unfiltered writes, and migration atomicity concerns. This goes beyond the annotations by describing analytical 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 a single 25-word sentence that front-loads the main action ('Statically parse caller-supplied SQL') and conveys all key aspects efficiently. There is no redundancy or unnecessary detail.

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

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

Given the presence of an output schema and annotations, the description adequately covers the tool's purpose and key analytical capabilities. It does not explain how dialect affects analysis or how invalid SQL is handled, but these may be covered by the output schema. It is sufficient for a user to select this tool appropriately.

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. It implicitly describes the 'sql' parameter as 'caller-supplied SQL', but it does not mention the 'dialect' parameter or explain how it affects parsing. With two parameters, this is a meaningful gap.

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 specific verbs ('parse', 'inventory', 'flag') and identifies the resource ('caller-supplied SQL'). It distinguishes itself from sibling tools like code-change-review by emphasizing static analysis without database connection or execution, making its purpose unambiguous.

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

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

The description implies the tool is used for reviewing SQL changes statically but does not explicitly state when to use it versus alternatives, nor does it provide exclusions or mention sibling tools. It gives context (no DB execution) but lacks direct guidance on selection.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses important behavior: deterministic output, inclusion of source hashes, and explicit truncation evidence. This adds meaningful context about what the tool returns and how it handles large inputs, which annotations alone do not cover.

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

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

The description is a single, dense sentence that front-loads the verb and resource, then packs critical behavioral details (deterministic, hashes, machine-readable diff, truncation evidence) without any superfluous 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 moderate-complexity diff tool with annotations and an output schema, the description covers the essential usage context and return characteristics. The mention of truncation evidence addresses an edge case likely relevant for large structured documents, making it complete enough for effective tool selection.

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. However, it does not explain the before/after parameters beyond implying comparison, nor does it clarify the format enum or input constraints. The parameter names are somewhat self-explanatory, but the description adds little value for parameter usage.

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 ('Compare'), identifies the exact resource ('JSON or YAML'), and clarifies the deterministic nature and output (hashes + additions/removals/replacements by path). It clearly distinguishes from sibling tools like document.diff by focusing on structured 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?

The description clearly implies the tool is for deterministic comparison of JSON or YAML structured data, which sets context for use. However, it does not explicitly exclude alternatives or mention when another tool (e.g., document.diff) would be preferred, so it stops 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?

Annotations already declare readOnly, idempotent, and non-destructive. The description adds valuable operational context: 'without paying' (cost behavior), 'grade' (evaluation output), 'presence and traction' (data checks), and 'buyer-concentration caveats' (ranking limitations). No contradiction with annotations.

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

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

The description is a single sentence, but every clause contributes substantive info (probe, grade, presence, rank). It is front-loaded with the key action 'Probe a public endpoint without paying'. It could be more pointed, but it's not verbose or redundant.

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

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

Given the tool's complexity (5 parameters, multiple investigation targets), the description covers the main behaviors enough for selection and invocation. An output schema exists, so return-value detail is not needed. It could mention more about the grading scale or list criteria, but it remains adequately 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 0%, so the description must compensate. It indirectly maps params: 'probe a public endpoint' suggests url and implies HTTP request (method/body), and 'rank licensed market matches' implies market_query/market_limit. However, body and method are not explicitly explained, leaving gaps in 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 uses specific verbs ('probe', 'grade', 'check', 'rank') tied to a concrete resource (x402 v2 challenge, x402-list, licensed markets). It clearly differentiates from sibling tools by focusing on x402-specific preflight actions, leaving no ambiguity about 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?

It establishes clear usage context: probe a public endpoint without paying and evaluate x402-related properties. It implies when to use the tool (before paying for access, to preflight), but does not explicitly state alternatives or exclusions. This is clear context without formal when-not guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing safety. The description adds value by specifying the output composition (line additions, removals, unified diff) beyond what annotations state, while remaining consistent with read-only behavior. No contradictions found.

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: 'Compare two texts and return structured line additions, removals, and a unified diff.' Every word earns its place, with no fluff or repetition of schema 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?

Despite missing usage guidelines (covered separately), the description sufficiently outlines purpose and output. The schema provides parameter constraints, annotations cover safety, and an output schema exists to explain return values. The only gap is the meaning of 'context_lines', but it is a standard diff concept and constrained by the schema.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase 'two texts' implicitly corresponds to 'before' and 'after', but 'context_lines' is not mentioned or explained. Parameter names are self-explanatory, and the schema includes type/length constraints, so partial compensation is achieved.

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 ('Compare') and resource ('two texts'), and specifies the output: 'structured line additions, removals, and a unified diff.' This is unambiguous, though it doesn't explicitly differentiate from the sibling 'developer.structured-diff', which could serve a similar purpose for structured 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention contexts, exclusions, or naming sibling tools that might be more appropriate for structured diffs. The description simply states what it does without usage direction.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds that the tool outputs 'clean text and metadata' and lists supported formats, but does not disclose additional limitations or behavioral details beyond that.

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

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

The description is a single concise sentence, front-loading the core function and listing supported formats efficiently without wasted words. Every word contributes to the purpose.

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

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

The tool has only 2 required params, an output schema exists, and annotations cover safety, so the description needn't explain return values or safety. It adequately covers purpose and supported formats, though it could mention the need for base64 encoding and format-specific caveats. Overall, it is sufficiently complete for the tool's 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. It lists supported document formats but does not explain that content_base64 is the Base64-encoded file content, nor does it clarify the relationship between filename and content. The parameter names are self-explanatory but the description adds minimal semantic detail beyond the schema.

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

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

The description clearly states the tool extracts clean text and metadata from a specific list of document formats, using the verb 'extract' and naming the resource. It distinguishes itself from siblings like web.extract by focusing on supplied documents rather than web URLs.

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 this tool is for extracting text/metadata from supplied files, but it does not explicitly state when to use it vs alternatives like web.extract or document.tables. No exclusions or conditional recommendations are provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds valuable behavioral details: deterministic matching, overlap-safe handling, and strict validation (Luhn, checksums, structural validity) that go beyond the schema. It does not contradict annotations; 'redact' is a pure transformation in this 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?

A single, dense sentence conveys all essential information without repetition or filler. It front-loads the core action and then lists precise details, making it highly 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?

Given the tool's moderate complexity, the description covers the key behavioral aspects (determinism, supported types, validation rigor, overlap safety) and is supported by a rich input schema and output schema, so an agent has enough context to invoke it correctly. The only minor gap is the omitted 'types' default, but that is not critical given the schema and 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?

Schema description coverage is 0%, so the description must compensate. It does so by clarifying what 'types' supports (emails, phones, IPs, cards, IBANs, SSNs) and by adding validation semantics like 'validated IPv4/IPv6' and 'Luhn-valid payment cards'. However, it does not state the default behavior when 'types' is omitted, leaving some ambiguity.

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 ('detect and redact'), names the resource ('PII and personal data in supplied text'), and enumerates exact detection categories. It clearly distinguishes this tool from sibling tools like document.extract or data.clean by emphasizing deterministic redaction with validated matching.

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

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

The description gives clear context for when to use the tool: when PII redaction is needed with deterministic, overlap-safe matching for specific entity types. It does not explicitly name alternatives or state when not to use it, so it stops 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to cover safety. It adds the format support but nothing about error handling, size constraints (though schema has maxLength), or what happens with malformed documents. This is borderline but acceptable given the annotations and output schema.

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

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

The description is a single sentence with no redundant words. It is front-loaded with the main action and includes only necessary qualifiers (formats).

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 straightforward: take a document, extract tables. An output schema exists, so return values are defined elsewhere. The description misses parameter semantics but otherwise provides a complete picture 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 description coverage is 0%, so the description should compensate, but it doesn't mention the filename or content_base64 parameters at all. It only says 'supplied documents,' which is vague and doesn't explain how the document is passed or the relationship between the two required 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 uses a specific verb ('Extract') and resource ('structured table rows and columns') and clearly distinguishes it from sibling tools like document.diff, document.extract, and document.redact by specifying the exact output (tables) and input formats (HTML, DOCX, CSV).

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?