AgentRXI

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and network reach are covered. The description adds genuinely useful behavioral context beyond that: the external selector databases it may consult and the per-call cost ($0.002 USDC via x402), which materially affects invocation decisions.

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 front-loaded sentences: the first defines what is decoded and returned, the second covers input resolution and cost. No filler, and the highest-value information leads.

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-parameter read-only tool with no output schema, the description already states the return shape (name and typed arguments) and the cost/lookup mechanisms. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, including the JSON-ABI-or-signature forms and the topics format. The description adds no format or syntax detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (decode) with two concrete resources (EVM calldata, event log) and names the output shape (function/event name plus typed arguments). This clearly separates it from the sibling abi_encode without needing to open either schema.

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

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

Explains the input pathways — supply your own ABI, a human-readable signature, or let it look the selector up in openchain/4byte — which tells the agent when this tool will succeed. It stops short of explicitly naming abi_encode as the inverse operation or stating when not to use it, so it is clear context without exclusions.

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

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

Annotations already cover the safety profile (readOnlyHint=true is consistent with a pure encoding computation; openWorldHint=true). The description adds genuinely non-structured information: the exact return shape ('0x data and selector'), tuple/array support via JSON args, and the per-call cost of $0.002 USDC (x402).

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

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

Front-loaded with the core verb and purpose, followed by the example, output shape, capability notes, and cost. It is a single dense sentence plus two short clauses with essentially no waste, though the cost sentence sits last where it is easy to skim past.

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

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

No output schema exists, and the description appropriately covers the return value ('0x data and selector'). Cost, supported types, and downstream usage are all addressed for a 2-parameter tool with high sibling density; only the missing 'when to choose this over abi_decode' guidance keeps it from being fully 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 only 50% — the required 'signature' parameter has no schema description at all. The description compensates by showing the signature format via example and clarifying that args accepts JSON (tuples/arrays), adding real meaning beyond the schema's terse 'JSON array, or | separated' note.

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

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

States a specific verb+resource — 'Build EVM calldata from a function signature and arguments' — and the concrete example ('transfer(address,uint256) + [to, amount]') makes the operation unmistakable. It is cleanly the inverse of the sibling abi_decode, so an agent can distinguish them without opening either schema.

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

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

Usage is only implied: the description notes the output is 'ready for a transaction or /v1/tx/simulate', which hints at the downstream context. It never states when to prefer this over abi_decode or what prerequisites the input must satisfy; the agent must infer the 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 declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond that: a concrete cost ($0.002 USDC per call via x402) and an extra detection scope (flags private keys and tx hashes pasted by mistake). It stops short of describing the return shape or failure behavior.

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

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

Front-loaded with the purpose and the pre-send-money intent, then a dense but useful chain enumeration, then cost. No filler sentences. The chain list is long but each entry conveys real supported coverage.

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

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

With no output schema, the description should ideally sketch what a result looks like (valid/invalid, checksum error, flagged-as-private-key). It says the tool 'checks' and 'flags' but never describes the return, leaving a gap for an agent that must interpret the result. Cost and safety are otherwise covered.

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% for the single 'address' parameter, so the description must carry the meaning. It partially compensates by enumerating the accepted formats and chains, telling the agent what kind of string to pass, but it does not state that the value is a single raw address string and gives no format constraints.

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

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

States a specific verb and resource ('Check a crypto address') and enumerates the exact address families supported (EVM EIP-55, Bitcoin base58check/bech32, Solana, Tron), which lets an agent scope the tool precisely. It does not, however, differentiate itself from the sibling 'address_verify' or 'btc_address', so the agent cannot tell from the text which validate-vs-verify tool to pick.

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?

'before sending money' gives a clear implied usage moment for the tool. But there is no explicit when-not guidance and no mention of the obvious alternative 'address_verify', leaving the agent to guess between the two siblings on its own.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful context beyond that: the operation performs a live connection sequence (initialize, tools, resources, prompts, auth check) and costs $0.004 USDC per call via x402 — a real behavioral/pricing constraint an agent should know before invoking.

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

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

The action statement is front-loaded before the colon-list of internals, and every clause carries information (targets, handshake contents, vetting purpose, cost). It is dense but not padded; only the enumeration could be trimmed slightly.

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

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

For a one-parameter, read-only, open-world tool with no output schema, the description covers what is contacted, what is retrieved (skills, auth, llms.txt), and the per-call cost. It leaves the exact return shape unspecified, which is acceptable given there is no output schema, but the deliverable of an 'inspect' call could be framed more concretely.

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

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

With a single parameter and 100% schema description coverage, the schema already documents that 'url' accepts an MCP endpoint or a site. The description's mention of 'remote MCP endpoint' adds no format or syntax detail beyond that, 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?

States a specific verb (Inspect) and resource (another agent or MCP server), then enumerates exactly what gets inspected: MCP endpoint handshake, A2A agent card, and llms.txt. This clearly distinguishes it from siblings like http_inspect, openapi_inspect, and site_agent_ready.

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 'before using it' gives a clear trigger condition (vetting a counterparty prior to interaction), and 'Vet tools and partners automatically' reinforces the use case. However, it never names alternatives such as http_inspect or openapi_inspect for non-agent endpoints, nor states when not to use it.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely useful non-schema behavior: the endpoint is an external (Open Library) source and it costs $0.002 USDC per call via x402, which is important for an agent budgeting calls. It omits pagination/limit behavior and error semantics, so not a 5.

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

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

One compact sentence names the capability, source, and returned fields, with the pricing constraint appended cleanly. No filler, and the most decision-relevant information is 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?

With no output schema, the description usefully enumerates return fields, and it discloses cost. However, for a 3-parameter tool with zero schema coverage and no output schema, it leaves pagination, parameter interaction (q vs isbn), and result-shape limits unspecified.

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

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

Schema description coverage is 0%, so the description carries the full burden. It hints that 'isbn' is an ISBN and that search is by book/title/author, but says nothing about 'limit' or about the relationship between q and isbn. The field list describes outputs, not input semantics.

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

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

States a specific verb+resource combo ('Book search and ISBN lookup') and names the data source (Open Library), plus enumerates the fields returned. An agent immediately knows what it gets. It does not explicitly differentiate from potentially overlapping siblings like papers, libdocs, or research, which keeps it short of a 5.

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

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

Naming two modes ('search' and 'ISBN lookup') implies that one uses a query and the other an ISBN, but there is no explicit when-to-use, no statement about whether the two can be combined, and no routing to alternatives. Usage is only implied.

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

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

With readOnlyHint/openWorldHint already declared, the description adds genuinely new behavioural context: the call costs $0.005 USDC via x402, and it returns unsigned approve + deposit transactions for the caller to sign rather than executing anything. It does not mention rate limits or failure/unsupported-route behaviour.

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 action and resource, with the cost caveat placed last. Every clause carries information, though the provider/chains parenthetical makes it long.

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

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

With no output schema, the description usefully describes the return payload (expected and minimum received, USD fees, time, unsigned transactions), and it discloses pricing, which is the main non-obvious call prerequisite. Remaining gaps are the undocumented non-required parameters, e.g. amount units and to_address/to_token expectations.

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

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

Schema coverage is only 25%, so the description must compensate, and it does so partially by enumerating the supported chains per provider (Ethereum/Base/Arbitrum/Optimism/Polygon vs BSC/Avalanche/Solana), which informs to_chain/from_chain. However, it adds nothing for amount format, to_token/to_address/from_address semantics, and omits slippage-related context for 'minimum received'.

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

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

Names a specific verb+resource ('bridge quote' / move tokens between chains) and scopes it with the exact providers and chains covered, so an agent can tell it produces cross-chain route quotes. It does not explicitly contrast itself with the neighbouring swap_quote/swap_build/route tools, so it falls short of a 5.

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

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

Usage is only implied: the description makes clear this is for moving tokens between chains, and that provider selection depends on the chain pair (Relay vs LI.FI). There is no explicit when-not or pointer to a sibling such as swap_quote for same-chain swaps.

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 (readOnlyHint, openWorldHint), and the description adds genuinely useful context beyond them: a per-call charge of $0.003 USDC via the x402 payment scheme. It still omits pagination behavior, address-format support, and any rate limits, so it is not fully complete.

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

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

Two sentences, front-loaded with the core purpose and the return payload, followed by the cost constraint. Every clause carries information; nothing is restated from the name or annotations.

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

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

With no output schema, the description does the work of describing return values well, which is the main completeness burden here. The remaining gaps are the undocumented `limit` parameter and the absence of any alternative-routing guidance.

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% and the description compensates only for `address` (implicitly, by naming it as the lookup subject). The `limit` parameter is never explained, so an agent cannot tell that it caps how many transactions are returned.

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

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

Opens with a specific verb+resource ("Bitcoin address lookup") and then enumerates exactly what is returned: balances in BTC and USD, totals received/sent, tx count, latest transactions. An agent can distinguish this from btc_tx or btc_fees from the description alone, though siblings are never named explicitly.

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

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

There is no when-to-use guidance and no routing against alternatives such as btc_tx (single transaction lookup) or wallet. The only contextual remark is pricing, which tells the agent nothing about when this tool is the right choice.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely new behavioral context that annotations cannot express: the metered cost of $0.002 USDC per call via x402, which an agent needs to budget. It does not mention freshness/caching or rate limits.

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

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

A single dense sentence, front-loaded with the core answer type before the detail list. Every clause adds returned-field information, though the enumeration makes it run long without structural breaks.

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

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

With no output schema, the description must carry the return-value burden, and it does so thoroughly, naming each fee tier and ancillary signal (mempool size, difficulty adjustment). It omits any note on data freshness or response structure, which is a minor gap for a zero-parameter read tool.

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

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

The tool takes zero parameters, which is the baseline-4 case per the rubric. The description appropriately spends no words on arguments and instead documents the return shape.

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

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

States a specific resource (Bitcoin fee rates) and enumerates exactly what is returned: sat/vB for next block, 30 minutes, 1 hour, economy, plus payment cost in BTC/USD. This clearly separates it from siblings like gas, solana_priority_fee, and defi_fees.

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

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

The framing 'what to pay to send Bitcoin now' implies the usage context, but there is no explicit when-to-use guidance, no mention of alternatives (e.g., gas for EVM chains), and no stated prerequisite for the x402 payment.

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

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

Annotations already mark it readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds two genuinely useful behavioral facts beyond the annotations: the tool is a paid call costing $0.002 USDC via x402, and it discloses the returned data surface (mempool vs confirmed, fee fields, RBF flag), which matters heavily since there is no output schema. It stops short of five because nothing is said about behavior for unknown/unconfirmed txids or caching.

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 densely packed sentence front-loads the core payload fields, then closes with the cost note. No filler, though the comma-separated return-field list reads more like a schema dump than a structured description.

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

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

With no output schema, the description usefully carries the return-value burden by enumerating every field an agent will get back, and it discloses the payment model. Gaps remain on input format and on how sibling tools should be chosen, but for a single-parameter read tool this is close to 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 0% and the single parameter txid carries no schema-level detail, so the description must compensate — yet it never mentions txid at all. It gives no format (64-char hex hash), no note about ambiguity between chains or testnet, which is especially costly for a metered $0.002 call.

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 establishes this as a Bitcoin transaction lookup tool by enumerating exactly what it returns: confirmation status, confirmations, fee in BTC and USD, fee rate, inputs/outputs, and RBF signaling. The verb is only implicit (it is a data-retrieval tool), and it never distinguishes itself from sibling transaction tools like tx_explain or tx_simulate, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus the adjacent tx_explain, tx_simulate, or btc_fees tools, despite those siblings clearly overlapping in scope. The only contextual note is the per-call price, which is a cost fact rather than usage 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 give readOnlyHint/openWorldHint, and the description adds real behavioral context beyond them: it produces a downloadable file plus click-through links rather than sending invites, and it discloses a per-call cost of $0.002 USDC via x402. Missing only failure/auth behavior 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?

One front-loaded sentence that leads with the action and packs output formats and cost without filler; only slight bloat from the parenthetical field list.

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

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

Output is adequately explained despite no output schema (download link + add links), but with 6 undocumented parameters and no required-param guidance, an agent still lacks enough to construct a call confidently.

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

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

Schema coverage is 0% for 6 parameters, so the description must carry the weight, and it only loosely does. It names fields (times, all-day, location, description, attendees, recurrence, reminders) without saying whether they are top-level params or nested inside 'events', and never addresses title, start, calendar_name, or duration_minutes mappings.

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

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

States a specific verb and resource — generating calendar invites as a .ics file — and names the concrete output artifacts (download link, Google/Outlook add links) that distinguish it from siblings like schedule or meeting.

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

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

Usage is implied by the description (make invites when you want an .ics file), but no explicit when-to-use/when-not guidance and no alternative named against siblings such as events, schedule, or meeting.

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 readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds material context beyond them: the call is paid ($0.004 USDC via x402) and the result is derived from passive CT logs rather than active probing. It does not explain what the x402 payment flow requires of the caller, which is the main remaining gap.

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

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

A single front-loaded sentence with a colon-delimited field list; the scope (CT logs, unexpired certificates) comes first and the cost is placed last, which is the right ordering. The field enumeration is dense but each item is decision-relevant, so there is little waste.

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

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

With no output schema, the description does the work of describing returns (names, wildcards, first-seen, valid-until, issuers, near-expiry certs), which is exactly what an agent needs to pick this over a generic domain lookup. The gaps are the undocumented `limit` parameter and the missing note on what x402 payment setup the caller must have.

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% and there are two parameters, so the description carries the full burden. It covers the `domain` parameter implicitly ('of a domain') but says nothing at all about `limit` – no meaning, no default, no bound – leaving half the schema undocumented in both places.

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

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

The description names a specific resource (subdomains and TLS certificates of a domain) and pins the data source to Certificate Transparency logs, which inherently separates it from live-DNS siblings like `dns` or audit-oriented tools like `domain_audit`. It is a noun phrase with no explicit verb, and it never names a sibling to contrast against, so it stops short of a clean 5.

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

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

Usage is only implied: the enumeration of CT-log fields ('wildcards', 'certificates expiring within 14 days') signals when the tool is relevant, and the x402 price is a real selection factor. There is no explicit when-to-use statement, no when-not-to-use, and no routing to `dns`, `domain`, or `domain_audit` for the overlapping questions.

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 supply readOnlyHint and openWorldHint, and the description adds genuinely non-redundant behaviour: the data is live, and each call costs $0.002 USDC via x402, which is critical for an agent deciding whether to invoke it. It does not cover things like rate limits or cache staleness, so it falls short of 5.

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

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

Three short sentences, front-loaded with what the tool returns, then the usage trigger, then the cost. No filler; every sentence carries information the agent needs.

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

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

With no output schema, the description carries the return-value burden and does so by listing the delivered metrics. Payment requirement, live-ness and the healthy flag are all disclosed, so an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so the single 'chains' parameter is already documented as comma-separated with a default of all five. The description enumerates the five chain names, which slightly reinforces the default set, but adds no new syntax or filtering semantics. Baseline 3 applies.

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

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

Names the exact resource (live health of five named chains) and enumerates the specific fields returned: latest block, seconds since it, average block time, gas price, base fee, utilisation and a healthy flag. This is plainly distinguishable from siblings like 'gas', 'rpc' or 'btc_fees' without opening any schema.

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

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

"Check before sending transactions" gives an explicit, actionable when-to-use. It stops short of naming an alternative or a when-not-to-use condition, so it is clear context rather than full routing guidance.

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

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

Annotations only declare readOnlyHint and openWorldHint; the description adds substantial operational context beyond them — the 50-item batch cap, a 40,000-character ceiling, and a metered x402 charge ($0.012 USDC per call) that is a prerequisite for invocation. It does not cover failure modes (e.g., what happens past the char limit), which keeps it from a 5.

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

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

Front-loaded with capability and use cases before cost details; each sentence carries load (limits and pricing matter for a paid tool). The pricing clause is dense but information-bearing rather than filler.

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

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

There is no output schema and five parameters with no schema documentation, yet the description only gestures at the return ('confidence and label counts') without describing the per-item shape or how text and items interact. Adequate to attempt a call, but an agent must guess at result structure and per-parameter usage.

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

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

With 0% schema description coverage, the description must carry all parameter meaning, and it only partially does: it maps labels, multi_label, and the batched text input ('up to 50 texts'), but never explains the distinction between `text` and `items` or what `instructions` controls. The mapping is inferable but not spelled out.

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

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

States a specific verb and resource: zero-shot classification of texts into user-supplied labels, with the batch ceiling (up to 50 texts), label mode (single or multi-label), and return content (confidence, label counts) all named. 'Your own labels' clearly separates it from siblings like sentiment or image_classify that use fixed taxonomies.

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?

Concrete application contexts are given ('Route tickets, tag leads, sort reviews'), so an agent knows what class of problem this solves. It stops short of explicit routing guidance such as when to prefer sentiment, moderations, or embed, so it lacks exclusion criteria.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavioral context: the call costs $0.025 USDC via x402, meaning an agent must consider payment before invoking — exactly the kind of auth/cost disclosure annotations cannot express. It also discloses the 40,000-character input limit and the shape of the output. Lacks any note on latency or failure modes.

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

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

A single dense but well-ordered sentence: what it does, input limits, what it returns, then cost. Every clause earns its place and nothing is repeated from the schema or annotations. Front-loaded with the capability, with the payment caveat at the end.

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 readOnlyHint covering safety and no output schema, the description does the necessary work by enumerating the return contents (line numbers, severity, concrete fixes, 0-100 score, positives) and the cost. The gap is input completeness: with four undocumented parameters, no required flags, and no explanation of focus/language, the agent cannot fully reason about a correct call.

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% for all four parameters, so the description carries the full burden. It only obliquely gestures at `code` and `url` ('up to 40,000 characters, or a GitHub file URL') and never even hints at `focus` or `language`. With zero required parameters it is also unclear which of url/code the agent must supply, leaving half the surface undocumented in both places.

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

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

States a specific verb+resource and a precise scope: a senior-engineer review of exactly one file, capped at 40,000 characters, accepting a GitHub URL. This cleanly separates it from sibling tools like code_run (execution), report_repo (repo-level analysis) and errorfix (fixing), without the agent needing to open any schema.

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

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

The input constraints (one file, 40k character limit, GitHub file URL accepted) imply when the tool fits, but no alternatives are named and there is no explicit when-not guidance. An agent must infer on its own whether to use this versus code_run, second_opinion or vulns for a security-focused pass.

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 openWorldHint=true, so the safety profile is covered by structured data. The description adds genuinely non-derivable behavioral context: this call is metered at $0.004 USDC via x402, which materially affects invocation decisions. It stops short of describing failure modes or rate/latency behavior, so it is not a 5.

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

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

The purpose question is front-loaded and the rest is dense, information-bearing enumeration with no filler sentences. It reads as one over-packed run-on list and the pricing note is tacked on at the end, which slightly weakens structure, but nothing is wasted.

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

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

With no output schema, the description carries the return-value burden and does so thoroughly (standards, proxy types, owner, verification, risky function list). Combined with the payment disclosure, an agent knows what it gets and what it costs; only address formatting and any pagination/truncation of the function list are unaddressed.

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

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

Schema coverage is 50% — 'chain' is documented with its allowed values in the schema, but 'address' has no description at all. The description never mentions either parameter, neither the expected address format (checksummed? hex length?) nor the chain default, so it fails to compensate for the uncovered required 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 states a specific inspection target ('What is this address? Wallet or contract') and then enumerates the exact analysis surface: token standard detection, proxy patterns (EIP-1967, beacon, minimal clone, EIP-7702), owner, Sourcify verification, and the function list. This enumeration clearly differentiates it from siblings like address_validate, address_verify, contracts, or token_scan without needing to open any schema.

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

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

There is no explicit when-to-use / when-not-to-use guidance and no alternative tool is named, despite many plausible siblings (address_validate, address_verify, abi_decode, token_scan, report_contract_audit). The only contextual signal is the price, which implies deliberate/paid use but does not tell an agent when to prefer this tool over another.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely new behavioral context the annotations do not carry: a per-call cost of $0.002 USDC and the x402 payment mechanism, which materially affects whether an agent should invoke it.

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

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

Two sentences, front-loaded with the core data payload and closing with the cost. The indicator list is long but each item is a distinct return field, so it earns its space; a tighter grouping could have saved a few words.

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

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

With no output schema, the description carries the full burden of describing returns, and it does so comprehensively by enumerating every profile field and indicator. Pricing and input form are also covered, leaving little an agent would need before calling.

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% and the single 'q' parameter is undocumented in the schema, so the burden falls on the description. It does compensate by stating the accepted forms ('name or ISO code'), the one thing an agent needs to pass correctly, though it gives no format examples for ambiguous cases.

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

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

The description names a specific resource (country profile) with a clear input form (name or ISO code) and enumerates the exact payload (capital, region, World Bank indicators), which is far more concrete than the sibling 'demographics' or 'economy' entries. It does not explicitly differentiate itself from those overlapping siblings, so it stops short of a 5.

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

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

There is no statement of when to use this tool versus the many overlapping siblings (demographics, demographics_area, economy, macro_us, labor). The phrase 'by name or ISO code' implies the input form only; no alternatives or exclusions are 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 readOnlyHint and openWorldHint, so safety is partly covered. The description adds genuinely new operational context: the exact upstream sources consulted, the longest-match crawl-delay semantics, and critically the $0.002 USDC per-call x402 cost, which an agent cannot infer from any structured field.

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

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

Front-loaded with the decisive question, followed by one dense but well-organized sentence grouping sources, semantics and cost. The enumeration is long but each item is informative; only minor tightening is possible.

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

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

With no output schema, the description must imply the return shape, and it does so partially by describing the sources checked and noting it 'lists which AI crawlers the site allows.' It does not state whether the verdict is returned as booleans per purpose, raw rule text, or a summary, which is the one remaining ambiguity for a permission-adjudication tool.

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

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

Schema coverage is 50%: user_agent carries its own description with examples, while url is undocumented. The description reinforces that user_agent drives which robots rules apply ('for your user agent (longest-match rules, crawl-delay)'), adding real meaning, but it never clarifies url's expected form (full URL vs. domain, http/https, path sensitivity), so the coverage gap is only partially compensated.

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

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

The opening question frames a precise resource check — 'May my agent fetch, index, train on or use this page?' — and the enumeration of robots.txt, Content-Signal, X-Robots-Tag, meta robots, TDM and ai.txt pins down exactly what is inspected. This is clearly distinguishable from siblings like crawl, sitemap or domain_audit, which fetch rather than adjudicate permission.

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 question format implies the tool is used before fetching or training on a page, and referencing 'your user agent' hints that UA selection matters. However, it never states when to call this versus crawl, x402_check or url_metadata, nor any exclusion or prerequisite. Usage is implied, not specified.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds genuinely useful context beyond them: DST-correct timezone handling, invalid-field detection (error behavior), and a per-call price of $0.002 USDC via x402. It does not state pagination or output shape, but pricing and validation behavior are real disclosures.

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 tight sentences, front-loaded with the primary capability and followed by supported syntax and cost. Every clause adds information; nothing is padding.

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

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

For a read-only tool with no output schema, the description conveys the return content (plain-English explanation plus upcoming run times), syntax support, DST behavior, validation, and cost. The main gap is the unexplained 'count' parameter.

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 carry the parameters, and it only partly does: it clarifies timezone semantics (any timezone, DST-correct) but never explains the 'count' parameter controlling how many run times are returned, nor the accepted expression format beyond examples.

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

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

States a specific verb (explain) and resource (cron expression) plus the secondary output (next run times). No sibling tool covers cron parsing, so no differentiation is required, and the scope (timezone-aware, DST-correct) is 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?

Usage is implied by the phrasing — use it to understand a cron expression or project its future runs — but there is no explicit when-to-use guidance, no exclusions, and no named alternative (e.g. schedule or timestamp) for adjacent scheduling questions.

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 only cover readOnlyHint and openWorldHint, so the description's disclosure that each call costs $0.002 USDC via x402 is genuinely additive and important for an agent deciding whether to call it. It also adds the 300-bar cap and the fact that change/high/low come back per period, but says nothing about rate limits or failure behavior.

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

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

A single dense sentence with no filler; the resource is front-loaded and the cost caveat closes it. It is long but every clause (pairs, intervals, bar cap, return fields, price) carries information an agent needs.

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

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

With no output schema, the description still conveys the shape of the return (OHLCV plus change, high, low for the period) and the critical cost/payment model. For a 3-parameter read-only market-data tool, an agent has enough to call it correctly; only pagination/default specifics are missing.

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

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

Schema coverage is only 33% (only interval is described in-schema), so the description must compensate and largely does: it defines pair as a Coinbase pair with format examples, bounds limit at 'up to 300 bars', and restates the interval enumerations. Only the default for pair/limit and whether limit is required remain unaddressed.

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

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

Names a specific verb+resource (OHLCV candles), scopes it to Coinbase pairs with concrete examples (BTC-USD, ETH-USDC, SOL-USD), and enumerates the supported intervals and 300-bar cap. It is unambiguous against generic siblings like crypto_price or chart, though it never explicitly names the alternative to use instead.

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 (historical bars for a pair) but never states when to pick this over crypto_price, token_chart, crypto_indicators or crypto_orderbook. No exclusions, prerequisites, or routing guidance are offered despite many overlapping crypto 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?

With annotations covering the read-only/open-world safety profile, the description adds genuinely new operational context: the 300-candle window and, importantly, a per-call cost of $0.003 USDC via x402, which is a real constraint the annotations do not express. It omits rate limits or auth mechanics beyond the payment hint.

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

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

Front-loaded with the core purpose, then the indicator list, then the cost. Every clause carries information and the pricing note is correctly placed last. The enumeration is long but each item is a distinct return field, so it earns its space.

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

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

Because there is no output schema, the description usefully enumerates the returned indicators, covering the response side well. However, for a tool with two undocumented inputs and a payment requirement, the missing pair/interval semantics and payment-flow detail leave the definition only minimally 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% and the two parameters (pair, interval) are completely undocumented. The description mentions the 300-candle window but never defines the pair or interval formats (e.g., 'BTCUSDT', '1h'), so it fails to compensate for the schema gap where compensation is required.

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

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

States a specific verb+resource ('technical indicators computed on 300 candles') and then enumerates the exact outputs (RSI 14, MACD, SMA/EMA, Bollinger, ATR, bias). An agent can immediately tell this apart from raw-data siblings like crypto_candles or crypto_price. It stops short of naming a sibling, so it falls just under a 5.

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

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

There is no when-to-use guidance and no mention of alternatives (crypto_candles, crypto_price, report_trading_signal) despite many adjacent siblings. The description only says what it returns, leaving selection to the agent. Implied usage at best, not explicit routing.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds genuinely new behavioral context beyond them: the x402 payment cost of $0.002 USDC per call and the Coinbase data source with a fixed 24-hour window. It does not mention rate limits or pagination, but for a read-only snapshot tool the cost disclosure is the high-value addition.

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 what the tool returns (gainers, losers, most traded) before the qualifiers (24h, fields, volume filter) and closes with the cost. No filler.

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

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

There is no output schema, and the description does name the returned fields (price, change, USD volume) and the pricing model, which is enough for an agent to invoke it. The only real gap is the undocumented quote parameter.

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 0%, so the description must carry the parameters. It explains min_volume_usd ('filtered by minimum volume') and implies limit ('top'), but the quote parameter is never mentioned, leaving its meaning (which quote currency, e.g. USD/USDC) undocumented anywhere.

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

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

Specific verb and resource: 'top gainers, top losers and most traded pairs over 24 hours' on Coinbase with price, change and USD volume. This clearly separates it from siblings like crypto_price, crypto_candles, crypto_orderbook without needing to name them.

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

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

The 'filtered by minimum volume' clause and the 24-hour window imply when this screener is appropriate, but the description never states when to prefer it over crypto_price or crypto_indicators, nor any exclusions or prerequisites (e.g., whether quote/limit are needed).

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

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

Annotations already cover the read-only and open-world profile, so the bar is lower. The description adds meaningful behavioral context beyond them: the per-call x402 cost of $0.002 USDC and the fact that quotes are 'live...right now' (freshness). It does not mention rate limits or failure modes, but the cost disclosure is real added value.

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, front-loaded with the core identity before drilling into returned metrics and cost. Every clause carries information; nothing is redundant padding.

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

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

With no output schema, the description appropriately enumerates the return contents, so return values are covered. But for a 2-parameter tool with 0% schema coverage, the total absence of any guidance on 'pair' format and the entirely unmentioned 'depth' parameter leaves a real gap an agent must guess at.

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% and the description does not compensate. It implies a 'pair' parameter exists but never states the expected format (e.g., BTC-USD), and 'depth' — the second parameter — is never referenced at all, leaving its units or meaning unexplained in both schema and prose.

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 gives a specific verb+resource ('Live Coinbase order book for a pair') and then enumerates exactly what the response contains (best bid/ask, spread in bps, USD depth within 1%, imbalance, slippage tiers). This clearly distinguishes it from siblings like crypto_price or crypto_candles without the agent needing to open a schema.

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

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

Usage is implied by the content (real-time depth/slippage analysis) and the cost note ('$0.002 USDC per call') gives a practical reason to weigh it against free alternatives. However, there is no explicit when-to-use guidance and no named alternative (e.g., crypto_price, swap_quote) for an agent deciding between market-data siblings.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful behavioral context beyond the annotations: the paid nature of the call ($0.003 USDC per call, x402). It does not say what happens on an unknown/missing CVE id or whether the metered cost applies to failed calls, which keeps it out of 5 territory.

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

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

Front-loaded with the payload contents, then the alternate mode, then the pricing. No filler sentences, though the first sentence is a long comma-list that could be tightened. Every clause contributes 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?

There is no output schema, so the description does the work of explaining return fields, and it does that thoroughly (CVSS, KEV deadline, CWE, affected versions, references). With only three loosely documented parameters and no pagination/error detail, it is near-complete 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 description coverage is 0%, so the description must carry the parameter burden. It implicitly maps 'id' to the details mode and 'q' to the keyword search mode, which is real added value, but 'limit' is never mentioned and no format/range hints are given for any of the three 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 names a specific resource (CVE records from the US NVD) and enumerates exactly what is returned: description, CVSS score/severity, CISA KEV status, CWE weaknesses, affected products/versions, references. It also covers the second mode (keyword search). It does not distinguish itself from the sibling 'vulns' tool, which appears to overlap in domain, so it stops short of a 5.

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

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

'Or search CVEs by keyword' implies the lookup-vs-search split, which is useful, but the mapping to the id/q parameters is left implicit and there is no when-not-to-use guidance or mention of the 'vulns' sibling. Usage is inferable 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 establish this is a read-only, open-world operation, so the bar is lower. The description adds genuinely new behavioral context: coverage breadth (100+ countries), non-standard Friday-Saturday weekend handling, and a per-call cost of $0.002 USDC via x402, which is material for an agent deciding whether to invoke it.

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

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

Two tight sentences, front-loaded with the core capability before the pricing note, with zero filler. The parenthetical use-case list is compact and informative rather than wasteful.

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 four-parameter tool with 0% schema coverage and no output schema, the description leaves too much unspecified: which parameter combinations are valid, what the return value looks like (a date vs an integer count), and required vs optional inputs. The mode/parameter mapping gap is the most serious omission.

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 0% and none of the four parameters (add, end, start, country) are documented anywhere. The description implies a mode split (add-offset vs start/end range) but never maps parameters to modes, nor specifies date format, whether `country` is required, or whether country accepts ISO codes or names.

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 specific operations (add/subtract working days, count working days between two dates) on a concrete resource (business days across 100+ countries), so the agent knows exactly what the tool computes. It does not explicitly differentiate itself from siblings like `holidays`, `business_counts`, or `time`, leaving that inference to the agent.

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

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

It gives example use cases (due dates, settlement, SLAs) which implies when the tool is useful, but never states when to prefer it over `holidays` (holiday lookup) or `time`/`timestamp`. No prerequisites or exclusions are given, so usage is implied rather than directed.

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

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

Annotations cover the safety profile (readOnlyHint, openWorldHint), and the description adds behaviors they cannot express: the hard 500-item limit, that normalization covers case/accents/punctuation, that semantic matching uses multilingual embeddings with a cosine threshold, and the $0.004 USDC per-call x402 cost. Cost and cap disclosure is genuinely useful; it stops short of saying how over-limit input or embedding failures are handled.

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

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

Three tight sentences: the operation and its two matching modes first, the return contract second, the price last. Every sentence carries information, though the middle clause packs embeddings, cosine threshold and multilingual scope into one dense phrase.

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

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

There is no output schema, so the description usefully states the return shape (unique list plus duplicate groups), and it discloses the cost and item cap an agent needs before calling. Gaps remain around over-limit behavior and the semantic/threshold interaction, but nothing essential is omitted for a three-parameter tool.

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

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

Schema coverage is only 33% (only threshold is documented in the schema), so the description must compensate. It does clarify that items is the string list to deduplicate and that semantic toggles meaning-level matching, but it never states the boolean's default explicitly nor reconciles the threshold range with semantic=false, leaving some inference required.

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

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

The description names a specific verb (remove duplicates/near-duplicates) and the exact resource (a list of up to 500 strings), then distinguishes itself from generic text utilities by specifying both exact normalization and embedding-based semantic matching. An agent can tell what this does and that it is not text_diff or json_repair.

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?

Use is implied clearly enough (deduplicating a string list), but there is no explicit when-to-use/when-not guidance, no note on what happens above the 500-item cap, and no pointer to an alternative sibling. For a tool with no close sibling, implied usage is acceptable but the boundaries are left for the caller to infer.

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

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

Annotations only declare readOnlyHint and openWorldHint; the description adds the material behavioral fact that each call costs $0.003 USDC via x402, which an agent must know before invoking. It stays silent on rate limits, pagination, and how the limit truncates results, so it is not fully transparent.

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

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

Two tight sentences with the core capability front-loaded and the cost caveat last; every clause earns its place and there is no filler.

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

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

For a three-parameter read tool with no output schema, the description covers the query modes and the payment requirement, which is most of what an agent needs. The unexplained 'limit' parameter and absent output-shape hint leave a small but real gap.

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

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

Schema description coverage is 0%, so the description carries the burden: it explains that 'chain' scopes to one chain and 'protocol' retrieves that protocol's history, adding real meaning for two of three parameters. The third parameter, 'limit', is never mentioned or given units/semantics, so compensation is only partial.

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

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

States a specific resource (DEX trading volume) with concrete metrics (24h/7d volume with change) and enumerates the query modes, which cleanly separates it from siblings like defi_tvl, defi_fees and defi_yields. An agent can tell what this returns without opening the schema.

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

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

The three modes (overall, per-chain, single-protocol history) map onto the chain/protocol parameters, effectively telling the agent when to use each form, and example protocols (uniswap, aerodrome, raydium) are given. It never names alternative sibling tools or states exclusions, so it stops short of full alternative routing.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=true), so the description's job is to add beyond that, and it does: it discloses a concrete per-call cost of $0.003 USDC via x402, a real behavioral constraint an agent must account for. It does not mention rate limits, pagination, or the response envelope, keeping it below 5.

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

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

Two dense sentences plus a short cost line, with the core purpose front-loaded and no filler. The time-window enumeration (24h / 7d / 30d / all-time) is slightly list-heavy but informative rather than wasteful.

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

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

With no output schema, the description carries the return-value burden and does so reasonably: it describes what is returned (fees or revenue, ranked, or per-protocol totals over four windows). Missing pagination/limit behavior and any mention of response format, so not fully complete for a 4-parameter 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 only 25% (only 'type' is documented), so the description must compensate. It clarifies type=revenue and maps the two query modes onto the protocol/chain/limit parameters implicitly, but limit and chain are never explained and no format or default details are added beyond the schema.

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

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

The description states a specific resource (protocol fees/revenue) and the two query modes (ranked list across protocols/chains vs. a single protocol's time-window totals), which clearly distinguishes it from data siblings like defi_tvl, defi_dexs, and defi_yields. It does not name any sibling explicitly, so it stops short of a 5.

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

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

The two modes are implied by the wording ('for every protocol and chain, ranked, or one protocol's totals'), which hints at when each parameter shape applies, and 'fundamental data for valuing tokens' gives a use context. But there is no explicit when-to-use vs. alternative guidance or statement of prerequisites.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely new behavioral context: a per-call cost of $0.002 USDC via x402 and the fact that three independent resolvers are consulted and compared. It does not mention rate limits or response shape, but the payment disclosure is the important non-obvious trait here.

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

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

Front-loaded with the core capability, followed by the reverse-DNS hint and cost. Dense but nearly every clause carries information; the record-type enumeration is slightly long but defensible as it defines scope.

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

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

There is no output schema, so the description carries the return-value burden, and it does so reasonably by naming propagation agreement, DNSSEC status, SPF and mail provider. Payment and reverse-DNS behavior are covered; only output structure and error behavior are unstated.

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

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

Schema coverage is 67%: type and compare are documented in the schema, but the required `name` parameter has no description. The description partially compensates by implying `name` accepts a hostname or an IPv4 for reverse lookups, and it lists valid record types that overlap the `type` default. Baseline 3 is appropriate given the partial 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?

States a specific verb (lookup) and resource (DNS records) with explicit scope: three named resolvers queried at once. It enumerates the record types and the extra analyses (propagation agreement, DNSSEC, SPF, mail provider), which clearly separates it from siblings like domain, domain_audit, ip, or report_domain.

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?

"Give an IPv4 for reverse DNS" is a concrete usage instruction for one mode, but there is no when-to-use/when-not guidance and no routing to or from siblings such as domain or domain_audit. Usage is implied rather than 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 only declare readOnlyHint and openWorldHint, so the description carries real weight here and delivers: results are checked live, capped at 15 names, each marked taken/likely available, TLDs customizable, and critically it discloses a $0.005 USDC per-call charge via x402 — a cost signal an agent must know before invoking.

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

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

One dense sentence that front-loads the value proposition, then the TLD scope, then the price. Every clause carries information; it is slightly long but no clause is filler.

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

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

For a two-param, no-output-schema tool with thin annotations, the description covers output shape (15 availability-marked names), TLD configurability, and the payment model. The main remaining gap is payment mechanics (wallet/credential prerequisites for x402) and the tlds input format.

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

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

Schema description coverage is 0% with two params, so the description must compensate. It maps 'idea' (business idea) and 'tlds' (or your TLDs), but gives no format guidance for the tlds string (comma-separated? dot-prefixed? count limits), leaving invocation detail to guesswork.

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

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

Specific verb+resource ('Brandable domain ideas') with a clear scope: up to 15 short names across named TLDs, availability-checked. Distinguishable from sibling domain tools (domain, domain_audit, report_domain) which do lookups/audits rather than ideation.

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 (you have a business idea and want name candidates) and states the output intent, but never states when to prefer this over sibling tools like domain, domain_audit or report_domain, nor any prerequisites beyond the idea input.

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 (readOnlyHint=true, openWorldHint=true), so the bar is lower; the description adds the critical non-obvious trait that each call costs $0.003 USDC via x402, which an agent must know before invoking. It does not mention size limits, partial-header failure behavior, or latency, but the paid-call disclosure is substantial value 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 dense sentence that front-loads the input form and then the analysis outputs, plus a short cost sentence. Every clause maps to a real capability, though the enumeration is long enough to read more like a feature list than prose.

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

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

With no output schema, the description compensates by listing what is returned (auth results, mismatches, relay path, origin IP, attachments, links, spoofing-risk level). The paid-call note covers the transactional aspect. Missing only edge-case behavior such as handling of malformed or header-only input.

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% and the single 'raw' parameter is an undescribed string, so the description carries the burden. It specifies that the value is a raw email and may be a full .eml source or just headers, which meaningfully constrains what to pass; it stops short of stating encoding or whether partial headers degrade results.

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

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

States a specific verb and resource (analyse a raw email / .eml source or headers) and enumerates the analysis surface: SPF, DKIM, DMARC, header mismatches, relay path, origin IP, attachments, links, phishing wording, spoofing-risk level. That scope is unmistakably distinct from siblings like email_verify (deliverability of an address) or email_inbox (mailbox access), so an agent can pick it without opening the schema.

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

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

The description implies when it applies by specifying accepted inputs (.eml source, or headers alone), which is useful narrowing. However, it never names an alternative (email_verify, email_inbox, http_inspect) or states an exclusion, so routing is inferred rather than guided.

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

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

Annotations only supply readOnlyHint and openWorldHint; the description adds material context beyond them, notably the $0.002 USDC per-call cost via x402 and the op=all batching behavior. It stops short of describing error handling, input size limits, or output format, so it is not a 5.

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

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

Front-loaded with the capability list, then the batching behavior, then the price — a sensible order with no filler. The first sentence is dense but every clause (each algorithm and encoding) does informational work.

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

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

With no output schema, the description should indicate the return shape (raw hex string vs. a JSON object of multiple digests), which it does not. What it does cover — supported ops, batching, and pricing — is adequate for invocation but leaves an agent guessing at the response.

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

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

Schema coverage is only 33% (only `key` is annotated as 'For hmac-sha256'). The description partially compensates by listing the algorithm/encoding domain that the undocumented `op` parameter selects from, but it never gives the literal op values or explains `text` beyond the obvious.

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

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

Names a specific verb+resource ('Hash and encode text') and enumerates the exact algorithms and encodings covered (SHA-256/1/512, MD5, HMAC-SHA256, Base64/Base64url, hex, URL, UUID). This clearly separates it from neighbors like abi_encode, jwt_decode, sign_verify, and password_check.

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

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

Usage is implied by the enumeration of supported operations and the note that op=all returns every hash and encoding at once, which is a genuine selection hint. However, there is no explicit when-to-use/when-not guidance and no routing to or away from any sibling tool.

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

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

Annotations cover the safety profile (readOnlyHint, openWorldHint), and the description adds genuinely useful behavior beyond them: a 20,000-character truncation limit and a per-call cost of $0.008 USDC via x402. It omits what happens when both url and text are supplied, or when neither is, which matters given zero required parameters.

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-loaded with the capability and output categories, followed by the two hard operational facts (truncation, price). No filler.

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

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

With no output schema, the description compensates well by enumerating the entity types returned. The remaining gap is the input-selection rule for url vs text, which an agent calling with zero required params would need.

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

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

Schema coverage is 0%, so the description must carry both parameters. 'from text or a URL' conveys that url and text are alternative inputs, but it does not state precedence or mutual exclusivity, leaving the two-parameter contract partly ambiguous.

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

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

States a specific verb+resource (named-entity extraction) and enumerates the exact output categories (people with roles, orgs by type, places, ISO dates, money, products, events, topics, emails/URLs/hashtags), which is unusually informative. It does not, however, differentiate itself from adjacent siblings such as extract, structure, or pii_redact, so it stops short of a 5.

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

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

There is no explicit when-to-use guidance and no named alternative, despite several plausible siblings (extract, structure, summarize, pii_redact). The only routing signal is the implicit input constraint (text or URL), which the agent must infer.

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