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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds no behavioral traits beyond what the annotations cover—no auth requirements, rate limits, side effects, or conditional behavior beyond the optional encoding step, which is already implied by the purpose.

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 sentence that is front-loaded and free of filler. Every clause contributes to understanding the tool's purpose, making it appropriately sized for a utility of this simplicity.

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

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

With no output schema and no parameter descriptions in the schema, the description is too thin. It does not explain the expected signature format, what the returned selector/topic looks like, or how arguments should be structured for encoding, leaving significant gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It names 'signature' and 'args' but provides no format details (e.g., function signature syntax), type information, or constraints, leaving key semantics undefined.

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

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

The description states a specific verb and resource: compute a function selector and event topic from a signature, and optionally ABI-encode a call with args. It clearly conveys the utility's role, though it does not explicitly distinguish itself from siblings like decode_calldata or convert_units.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description implies usage (compute selectors/encode calls) but offers no context, prerequisites, or exclusions, leaving the agent to infer from the tool name and purpose.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful provenance by naming the aggregated data sources (Blockscout, ENS, token lists, OFAC), but says nothing about rate limits, latency, or coverage gaps across chains.

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

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

A single front-loaded sentence that is densely informative with zero filler. Every token (each label source) earns its place.

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

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

With no output schema, the description usefully enumerates the return categories, which is exactly what the agent needs for an aggregated lookup. The remaining gap is usage/routing guidance rather than return-value disclosure.

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 of parameter meaning but adds none. The only hints ('EVM address') are already implied by the schema's enum and address regex, leaving chain/address semantics unexplained in the description.

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

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

States the specific resource (public labels for an EVM address) and enumerates the label sources it returns (Blockscout name/tags/token, ENS, token-list, known spender, OFAC SDN). However it does not explicitly differentiate itself from overlapping siblings like inspect_address or sanctions_check.

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. With siblings such as inspect_address and sanctions_check that overlap on address inspection and OFAC screening, the agent is left to infer routing entirely 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=true and openWorldHint=true, so the safety profile and the fact that it hits external sources are covered. The description adds genuinely useful behavioral context beyond that: the quoting sources and the returned fields (amount received, cost, ETA), which tells the agent what it gets back from a live, aggregated call.

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

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

A single well-formed sentence that front-loads the action and packs in assets, chains, providers, and return fields without filler. Dense but readable; no wasted words.

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

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

For a read-only quoting tool with no output schema, the description usefully sketches the return fields and data sources, and annotations cover side effects. However, input amount semantics and any freshness/rate-limit expectations are absent, leaving gaps an agent may 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 description coverage is 0%, but the schema's enums for from/to (chains) and asset (USDC/ETH) are self-documenting, and the description restates that domain scope. The 'amount' parameter is never explained (units, token decimals, native vs smallest unit) and the description adds little beyond the schema, so it only partially compensates for the coverage 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?

Specific verb+resource combination ('Live bridge quotes') with explicit scope: assets (USDC/ETH), supported chains, and providers (Across, LI.FI, Relay). No sibling tool does bridge quoting, so it is unambiguous relative to the surrounding toolset.

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 purpose implies when the tool is relevant (comparing bridge costs), but there is no explicit when-to-use/when-not guidance and no named alternatives. For a cost-comparison tool, guidance like 'use before executing a bridge' would have earned a higher mark.

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 the ranking criterion and the DefiLlama categorization, which is useful, but says nothing about the limit parameter's effect, defaults, or result size.

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

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

A single front-loaded sentence that states resource, ranking, source, and the optional filter with zero 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 simple read-only ranked-list tool with no output schema, the description covers what is returned and the optional filter. Only the limit parameter's behavior is missing, a minor gap.

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

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

Schema coverage is 0%, so the description must carry the burden. It explains the chain filter but ignores the limit parameter entirely (no default, no max, no semantics), leaving half the parameters undocumented in both schema and description.

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

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

States a specific verb and resource ('bridges ranked by TVL') plus the data source (DefiLlama bridge categories). It implicitly separates itself from chains_tvl by saying 'bridges' rather than chains, but never explicitly names the sibling or the boundary.

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?

Only 'optionally filtered by chain' hints at usage; there is no when-to-use, no exclusions, and no pointer to alternatives like bridge_quotes (quotes) or chains_tvl (chain-level TVL). The agent must infer the 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=true and openWorldHint=true, so safety is covered. The description adds output granularity (argument-level and 32-byte-word-level differences), but says nothing about how decoding behaves without a signature or what happens on mismatched ABIs.

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 well-formed sentence that front-loads the action and tucks the use case into a parenthetical. 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?

The description does characterize the return shape (per-argument and per-word diffs), which partly compensates for the absent output schema. But with 0% schema coverage on three parameters, an agent still lacks the information needed to supply 'a', 'b', and especially 'signature' correctly.

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

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

Schema description coverage is 0% and the description never mentions the three parameters at all. The optional 'signature' field is especially important — whether it is required for decoding or merely a hint is left entirely unexplained.

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

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

States a specific verb+resource: decode two calldata blobs and list differing arguments and 32-byte words. The dual-input 'diff' framing implicitly distinguishes it from the decode_calldata sibling, though it never names it 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?

The parenthetical '(review multisig/governance payloads)' suggests the intended scenario, which is useful context. However, it gives no explicit when-to-use vs when-not guidance or alternative tools (e.g., decode_calldata for a single blob).

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 the useful 'DefiLlama nightly snapshot' freshness caveat, but says nothing about return shape, sort order, or how the limit behaves.

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 short sentence, front-loaded with the resource and scope. Nothing is wasted, though the terseness is partly what leaves gaps elsewhere.

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

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

With no output schema, the description should at least hint at the ranking contents and how 'limit' shapes the result. It gives the data source and freshness but leaves return format and pagination behavior 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?

The single parameter 'limit' has 0% schema description coverage and is never mentioned in the description, so its meaning (number of chains returned?) is left to guesswork. The schema's min/max bounds constrain it, but the description does not compensate for the missing semantics.

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

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

The description names a specific resource and scope: a DeFi TVL ranking broken down by chain, sourced from DefiLlama. It implicitly distinguishes itself from the sibling top_defi_protocols (protocols vs. chains) and get_chain (single-chain metadata), though it never states that distinction 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 guidance on when to use this tool versus alternatives such as top_defi_protocols or get_chain, nor any prerequisites or exclusions. The agent must infer the use case entirely from the phrase 'by chain'.

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 only readOnlyHint and openWorldHint, so the description carries the rest of the burden. It discloses that two external services are queried and enumerates what Blockscout returns (name, compiler, licence, proxy and implementations), which tells the agent this is an open-world network call with a variable result shape.

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 with zero filler; the core question is front-loaded and the supporting detail about data sources and returned fields follows. Every clause earns its place.

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

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

With no output schema, the description compensates by naming the fields Blockscout surfaces, which is the right material to include. It omits failure/unverified behavior, per-chain differences, and any rate-limit or latency note, leaving minor gaps for a two-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?

Schema coverage is 50%: chain carries an enum plus description, address carries only a regex pattern. The description adds no parameter-level detail beyond implying the address is a contract, which is a marginal semantic hint. Baseline 3 is defensible because the schema already constrains both parameters tightly (enum and 0x-40-hex pattern).

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 question ('Is a contract's source verified?') and names the exact upstream sources consulted (Sourcify full/partial match, Blockscout). An agent can tell this apart from read-only siblings like inspect_address, though no sibling is named explicitly to sharpen the boundary.

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, no exclusions, and no alternative tools named. The agent must infer from the phrasing that this is the verification-status lookup rather than, say, inspect_address or abi_utils, with no stated condition selecting one over the other.

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?

Annotation readOnlyHint=true is consistent with a pure conversion tool. The description adds that conversions are exact, implying no rounding or approximation. However, it doesn't disclose input/output format details (e.g., value as string representing a number, decimal support), which are behavioral traits beyond annotations.

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

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

Extremely concise single sentence that front-loads the core purpose. Every word earns its place with no redundancy.

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

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

For a 2-param tool with no output schema, the description is minimal. It should clarify input format (e.g., decimal string) and possibly return format. The annotations help by confirming read-only nature, but the description leaves gaps in usage and parameter details.

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

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

Schema description coverage is 0%, so the description must compensate. The listed unit pairs partially compensate by implying the 'unit' parameter should be one of those units, but the 'value' parameter is not addressed at all (format, precision, etc.). Baseline 3 is appropriate given partial compensation.

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?

Clear verb 'conversion' and specific resources (cryptocurrency units). The listed unit pairs (wei/gwei/ether, sat/btc, lamport/sol) clarify scope, but the description doesn't explicitly distinguish from siblings like gas_prices or get_chain.

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

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

No guidance on when to use this tool versus alternatives. The description states what it does but not the context or conditions for use. An agent must infer from the name and unit pairs alone.

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 safety and external-dependency profile are partly covered. The description usefully confirms the external lookup against openchain/4byte and the signature override, but says nothing about behavior when the selector is unknown, error modes, or network requirements.

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

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

A single tight sentence, front-loaded with the action and followed by the resolution rule. 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 two-parameter tool with no output schema and no parameter descriptions in the schema, the description covers the core mechanism but omits input format for 'data', the expected return shape, and failure behavior for unrecognized selectors.

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 for both parameters. It explains the role of 'signature' (bypasses the 4byte lookup) but says nothing about 'data' format (e.g., 0x-prefixed hex) or whether a signature must be a full ABI function signature.

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) and resource (EVM calldata), plus the resolution mechanism (4-byte selector lookup). It does not, however, distinguish itself from siblings like decode_transaction or abi_utils, which an agent could easily confuse it with.

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 clause 'unless a signature is given' implies the invocation choice: pass a known signature to skip the lookup. But there is no explicit when-to-use guidance or exclusion relative to decode_transaction/abi_utils, so the agent must infer the boundary itself.

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

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

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds that decoding happens offline, which is useful behavioral context (no network call), but it does not disclose error handling, supported PSBT versions, or other operational traits.

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 no filler; it efficiently lists the decoded fields after stating the core action.

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

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

With no output schema, the description usefully enumerates the return fields (inputs, outputs, addresses, fee, signatures, BIP-32 paths). Combined with the readOnly annotation, this is nearly complete for a decoder, though it lacks error-case expectations or PSBT version support.

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

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

The single psbt parameter has no description and 0% schema coverage, so the description carries the burden. It specifies that the input can be a base64/hex PSBT or a raw tx hex string, which adds essential format meaning beyond the bare 'string' type, though it could be more explicit about requiredness and 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?

The description states a specific verb, resource and scope: decode a Bitcoin PSBT (base64/hex) or raw tx hex offline, and enumerates the decoded fields. It is largely distinguishable from Ethereum decoders by Bitcoin/PSBT specificity, but it does not explicitly name the sibling decode_transaction or explain which to use for raw tx hex.

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 implies usage by specifying accepted input formats and that decoding runs offline, but it gives no explicit when-to-use or when-not-to-use guidance and does not mention alternatives like decode_transaction. An agent must infer suitability from the tool name and context.

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

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

Annotations already establish readOnlyHint=true, so safety is covered. The description adds useful behavior beyond that: it discloses that signature types are interpreted and that MultiSend batches are recursively decoded per inner call. It says nothing about handling of malformed/unsupported calldata or how failures are reported.

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, and the most important scope information (Safe execTransaction, MultiSend) is front-loaded. It is appropriately sized for the tool's simplicity.

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 some burden for explaining the return payload, and it does not (e.g., decoded call structure, signature output). For a one-input read-only decoder this is adequate but incomplete, since neither the input format nor the output shape is described.

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

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

There is a single parameter (data) with 0% schema description coverage, and the description does not compensate by specifying the expected format (hex string, 0x-prefix, byte length). The agent must guess the input encoding, which is a real gap for a decoder tool.

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) and resource (Safe execTransaction and MultiSend batch calldata), plus the notable extras of signature types and per-inner-call decoding. It is clearly narrower than the generic siblings decode_calldata/decode_transaction, though it never names those alternatives 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?

Usage is implied by the Safe/MultiSend scope: an agent can infer it should be used when the payload is Safe-specific calldata. There is no explicit 'use this when / use X instead' routing or mention of prerequisites, so guidance remains inferred 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 already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral context by enumerating what the decoded output includes: status, fee, compute units, parsed instructions, inner instructions, program names, and balance changes. It does not discuss error handling or rate limits, but it is transparent about the return content.

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 no filler. It efficiently states the operation and the decoded fields without redundancy.

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

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

There is no output schema, so the description appropriately explains the return values. It is nearly complete for a simple read-only decode tool, but it omits any note on the signature format or failure behavior, which would help an agent call it correctly.

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

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

Schema description coverage is 0% and the only parameter, signature, is not described in the schema. The description repeats that it is a Solana transaction signature but adds no format details such as base58 encoding or where to obtain it, so it does not compensate for the coverage 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 (decode) and resource (Solana transaction signature), and lists the decoded output categories. This distinguishes it from sibling decode tools such as decode_calldata, decode_transaction, and decode_psbt by naming the chain and object type.

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

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

The description explains what the tool does but gives no explicit when-to-use guidance, no exclusions, and no named alternatives. An agent can infer that it is for Solana transaction signatures, but the description does not help choose it over sibling decode tools.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. With no output schema, the description usefully discloses the return shape (status, fees, decoded call and event logs), adding real context beyond the annotations. It stops short of stating failure behavior for unknown hashes or chain availability.

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 sentence with the action and lookup key front-loaded, followed by a colon list of outputs. Every clause earns its place given the absence of an output schema, though the enumerated list is dense.

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

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

For a two-required-param read tool with annotations covering safety, the description compensates for the missing output schema by listing the decoded fields. Minor gaps remain around error handling and network-fetch semantics, but nothing essential to invoking it correctly is absent.

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?

Two parameters at 50% schema description coverage: chain carries an enum description while hash has only a regex pattern and no prose. The description's 'by hash' adds no syntax or format detail beyond the schema, so this sits at the baseline.

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

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

States a specific compound verb (fetch and decode) plus the resource and lookup key (transaction by hash), and enumerates the decoded payload (status, fees, call args, event logs). An agent can distinguish this from decode_calldata by the 'whole transaction by hash' framing, though no sibling is 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?

The description implies usage via 'by hash' but gives no when-to-use guidance, no prerequisites, and no routing against the close sibling decode_calldata. The agent must infer that this is for full transactions and decode_calldata is for raw calldata.

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 safety is covered. The description adds real context beyond that: data provenance and freshness (DefiLlama, nightly cadence) and the default TVL floor of $10m, which materially affects what the agent will receive.

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 tight, front-loaded pair of sentences that leads with the resource and scope before listing capabilities. No filler, though the second clause mixes usage hints with return fields in a slightly dense semicolon 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?

For a read-only, open-world data-retrieval tool with no output schema, the description covers source, scope, returned fields and main filters adequately. Only the two undocumented filter parameters (limit, minTvlUsd bounds) keep 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?

With 0% schema description coverage the description must carry the parameter burden. It documents chain, project, stablecoinOnly and both sort enum values, and hints at the TVL threshold behind minTvlUsd, but leaves limit and the exact minTvlUsd semantics undocumented.

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 (top DeFi yield pools), its scope (TVL ≥ $10m), the fields returned (APY, base/reward split, IL risk) and the data source (DefiLlama nightly). This clearly identifies the tool's job but never explicitly differentiates it from adjacent DeFi-data siblings like top_defi_protocols, chains_tvl or protocol_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?

It tells the agent what can be filtered (chain, project, stablecoin-only) and how to sort (tvl or apy), which implies the usage contexts. However, there is no explicit when-to-use, when-not-to-use, or alternative-tool routing, so guidance remains implicit rather than actionable.

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 safety and external-data traits are covered. The description usefully adds the data source and refresh cadence ('DefiLlama nightly'), which tells the agent the data may be up to a day stale — genuine context beyond the annotations. It does not describe pagination, sorting, or the shape of the response.

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 compact sentence with the resource front-loaded and the time windows and source appended. No filler, though the parenthetical source note is somewhat compressed.

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, so the description should ideally describe return structure, and it does convey the metrics included (24h/7d/30d plus market totals). However, the undocumented chain and limit parameters leave a real gap for a two-parameter query 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?

Both parameters (chain, limit) have 0% schema description coverage, so the description carries the full burden and fails: it never mentions that results can be scoped by chain or capped by limit, nor what 'limit' bounds (protocols vs rows). An agent would have to guess the semantics of both arguments.

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), the dimensions returned (24h/7d/30d), the aggregation level (by protocol plus market totals), and the upstream source. An agent can tell this is a volume-metrics lookup, though it does not explicitly distinguish itself from siblings like top_defi_protocols or protocol_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?

There is no guidance on when to use this tool versus the many adjacent DeFi-metrics siblings (top_defi_protocols, chains_tvl, protocol_fees). No prerequisites, no exclusions, no routing cues — the agent must infer selection from the name alone.

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 declare readOnlyHint and openWorldHint, so safety is already covered; the description adds real behavioral context by disclosing that supplying a signature triggers signer recovery and that erc1271 triggers an on-chain isValidSignature check on a smart account. It still omits error behavior (e.g., what happens on an invalid signature) and the exact response shape.

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 tightly packed sentence that front-loads the core action and appends the conditional branches in logical order. No wasted words, though the semicolon-chained clauses require careful parsing.

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 nested objects, three params, and no output schema, the description covers the main action and branches but leaves the typedData structure and the return format undocumented. It is adequate but not complete for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry the burden. It clarifies the role of signature (recover signer) and erc1271 (smart-account validity check), but says nothing about the required typedData object's internal structure (types, domain, message, primaryType) or the chain enum, leaving a meaningful gap.

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

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

The description states a specific verb and resource ('Hash EIP-712 typed data') and enumerates the three hash outputs (digest, domain separator, struct hash), so an agent knows exactly what the tool produces. It does not, however, distinguish itself from the sibling verify_message, which covers overlapping signature-verification ground.

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?

Conditional behavior is implied ('if a signature is given...', 'optionally check ERC-1271'), which hints at when each branch applies, but there is no explicit when-to-use guidance and no routing against the close sibling verify_message. Usage must be inferred from the branch conditions alone.

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 and external-lookup profile is covered. The description adds useful detail on the 50-item cap and the specific records fetched (avatar/url/twitter/github, primary-name check), but says nothing about behavior on invalid or unresolvable inputs or latency of an on-chain network call.

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

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

One front-loaded sentence that states the action, the cap, the returned data and the reverse mode, with no filler. Every clause earns its place.

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

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

There is no output schema, but the description summarizes the return payload (address plus avatar/url/twitter/github records and primary-name check) and the input bound. For a one-parameter bulk tool this is nearly sufficient; only error/partial-failure behavior for unresolvable inputs is missing.

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

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

Schema coverage is 0% and the single 'inputs' array has no per-property description, so the description carries the load. It compensates well by stating the array holds ENS names or addresses and is capped at 50 — element type and limit are otherwise absent from the schema. It does not clarify whether mixed name/address arrays are allowed.

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: 'Resolve up to 50 ENS names ... or reverse-resolve addresses', including the exact scope cap and returned record types. It is a clear, self-contained statement, though there are no ENS-related siblings to differentiate against, so the sibling-routing element of a 5 is absent.

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 its usage (bulk ENS forward/reverse resolution) but never states when to use this versus alternatives or any prerequisites, such as whether names must be normalized or what happens to unresolved entries. Context is implied rather than spelled out.

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, covering the safety profile. The description adds the return shape (stats plus a downsampled series) and the metric set, but discloses nothing about rate limits, pagination, or freshness beyond the block window.

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, front-loaded with the metric list and ending with the return format. No filler; every clause carries information. Slightly terse, but appropriate.

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

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

For a two-parameter read-only tool with no output schema, the description conveys the metrics, the block window, and the return shape, and annotations cover safety. Only the routing against gas_prices is missing for full completeness.

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

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

Schema coverage is 50%: chain is documented via its enum, but blocks carries no description in the schema. The description's 'last N (≤1024) blocks' clarifies the blocks parameter's meaning and bound, adding some value, though it largely restates the schema's maximum.

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

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

The description names the specific metrics (base fee, median tip, gas-used ratio) and the time window (last N blocks), so the resource and verb are clear. It does not explicitly distinguish itself from the sibling gas_prices, but the historical framing is evident.

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 or when-not-to-use guidance. The obvious alternative, gas_prices (current prices vs. this historical series), is never mentioned, leaving the agent to infer the choice from the name alone.

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, lowering the burden, and the description usefully adds that data comes from public RPCs (implying no auth) and that values are 'live'. It does not mention rate limits, caching, or failure modes when an RPC is unreachable, keeping it short of 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?

A single front-loaded sentence that opens with the core action ('Live fees from public RPCs') and then branches by chain tier using parallel semicolons. Dense but every clause carries information; slightly long for a one-sentence description but 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 takes on return-value disclosure and does so adequately by naming the fields returned (base fee, priority tips, native + USD cost, sat/vB, priority fee). It stops short of describing response shape or units for the EVM USD figure, but nothing critical for invoking the tool 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 0%, so the description must carry the load. It partially does: 'cost in native token + USD for a given gas amount' explains the purpose of gasUnits, and the per-chain tiers anticipate the chain enum. However it never states that gasUnits is EVM-only/irrelevant for bitcoin and solana, nor that chain 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?

The description states a specific verb+resource (retrieve live gas fees) and enumerates the per-chain semantics: EVM base fee + priority tips via eth_feeHistory with native/USD cost, Bitcoin sat/vB, and Solana priority fees. It is clearly distinguishable from every sibling (get_chain, decode_transaction, convert_units, etc.), none of which return fee data.

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

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

Usage context is implied by the chain-specific breakdown (an agent can infer it should pass 'bitcoin' for sat/vB and 'solana' for priority fees), but there is no explicit when-to-use/when-not statement and no named alternative. With no sibling tool competing for this job, the omission is not harmful, so an implied-usage 3 fits.

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 goes beyond that by disclosing the data source (chainid.network) and the shape of the returned record, which matters since there is no output schema.

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

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

One compact sentence, front-loaded with the action and lookup keys, with the returned fields and source trailing. No filler or redundant restatement of the name or title.

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 the returned fields, and annotations carry the read-only safety profile. It stops short of noting behavior for unknown chains or ambiguous short-name matches, a minor gap for a lookup tool.

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

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

Schema description coverage is 0%, so the schema contributes nothing about the single 'query' parameter. The description compensates by specifying the three accepted identifier forms (chain ID, short name, or name), which is exactly the missing semantic detail.

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

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

States a specific verb ('look up') and resource ('EVM chain') plus the accepted lookup keys (chain ID, short name, name) and the payload returned (native currency, RPCs, explorers). No sibling tool offers chain lookup, so an agent can route to this one unambiguously.

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 agent infers it should call this when it needs chain metadata. There are no explicit when/when-not statements and no alternatives named, but the lookup-key enumeration does hint at the input forms that are acceptable.

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, openWorldHint), and the description adds genuinely useful behavior: the return payload ('rows ... plus generation time and source') and the optional limiting of rows. With no output schema, this return-shape disclosure carries real weight; only pagination/error behavior is left unstated.

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, front-loaded with verb and resource, with the return shape trailing. It is dense but every clause (source of names, optional limit, return contents) carries information.

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

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

For a two-parameter generic fetcher with no output schema and no annotations on return shape, the description covers what comes back (rows, generation time, source) and how to constrain it, plus a pointer for discovering dataset names. Remaining gaps are pagination and failure modes, which matter less here.

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%: 'name' is fully exemplified in the schema, while 'limit' has only min/max bounds and no prose. The description's 'optionally limited' gives 'limit' its meaning, which offsets part of the gap, but nothing is said about units, default value, or behavior when omitted.

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 ('Fetch ... dataset by name') and adds scope ('any Blockchain Lab Open Data API dataset', 'see the catalogue'). It is clearly the generic fetcher among the curated single-dataset siblings (chains_tvl, stablecoins, dex_volumes), though it never names a sibling to sharpen the distinction.

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

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

The only direction is 'see the catalogue' for valid names; there is no guidance on when to prefer this generic tool over the curated siblings that surface many of the same datasets. An agent has to infer selection from the word 'any' alone.

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 and data-source profile is covered. The description adds the source domain and the omit-term listing behavior, but says nothing about unknown-term handling, matching behavior, or rate limits. No contradiction with annotations.

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

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

Two short sentences, zero filler, with the core purpose front-loaded and the optional-parameter behavior immediately after. 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?

For a single-parameter lookup with no output schema, the description covers what the tool returns ('plain-language definitions') and the listing mode. Only the error/empty-result behavior for an unknown term is left unstated, a minor gap.

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

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

Schema description coverage is 0%, so the description carries the burden for the single 'term' parameter, and it does explain the empty-value case (omit to list all). It does not clarify exact vs. fuzzy matching, case sensitivity, or what happens with an unrecognized term.

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 (plain-language blockchain definitions) and its source (blockchainlab.com), which lets an agent distinguish it from siblings like lookup_standard. The verb is implicit in 'definitions' rather than explicit like 'get', but the intent 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?

'Omit term to list all terms' gives concrete usage guidance for the no-argument mode, which is genuinely useful since term is optional. However, it offers no guidance on when to prefer this over lookup_standard or other sibling lookup tools, and no exclusions.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds operational context by enumerating what gets inspected (balance, nonce, proxy, EIP-7702, ERC-20 metadata) and noting checksum validation, but it doesn't discuss caching, rate limits, 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?

One dense, front-loaded sentence that avoids repetition. It is efficient though the long enumeration borders on a feature list rather 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?

For a read-only inspection tool with full schema coverage and annotations, the description covers the main capabilities but lacks details on output shape, error conditions, and when to use it versus siblings; adequate but with clear gaps.

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

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

Schema coverage is 100%: the schema already documents both parameters, including the chain enum and that address accepts ENS. The description adds little beyond what the schema provides.

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

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

The description lists specific verbs (resolve, validate, inspect) and a resource (address on a chain), enumerating concrete outputs like balance, nonce, contract/EOA, proxy implementation, EIP-7702 delegation, ERC-20 metadata. This clearly distinguishes it from siblings such as decode_transaction or decode_calldata.

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 only implies when to use it by listing capabilities; there is no explicit guidance on when to prefer this over alternatives such as get_chain or decode_transaction, nor any 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 useful context not in annotations — the data source and freshness ('L2BEAT nightly') — but says nothing about pagination, default result count, or how the limit behaves, which matters for a listing tool.

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

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

Two dense sentences with no filler; the resource/fields come first and the query/filter mechanics follow. Efficient, though the parenthetical source note could be tightened.

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 correctly compensates by enumerating the returned fields (stage, category, stack, risk summary, TVS breakdown). It is nearly complete, missing only return volume/pagination behavior for a tool with a limit 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 load. It usefully supplies the accepted stage values ('Stage 0/1/2'), which the schema lacks entirely as an enum, and clarifies that query matches name/id/stack. However, the limit parameter (1–100) is never explained, and query matching semantics (exact vs. partial) remain vague.

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

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

The description states the resource (Ethereum L2/L3 project metrics) and enumerates the returned fields (stage, category, stack, risk summary, TVS breakdown), which clearly separates it from sibling TVL tools like chains_tvl and bridges_tvl. It does not explicitly name a verb like 'list' or 'query', but the content and provenance (L2BEAT nightly) make the purpose unambiguous.

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

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

It tells the agent how to query (by name/id/stack) and filter (by stage), which implies usage, but gives no when-to-use vs. siblings such as chains_tvl or top_defi_protocols, and no exclusions or prerequisites. Adequate but leaves routing to inference.

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

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

Annotations already declare this as a safe, open-world read, so the safety profile is covered. The description adds only that data comes from 'Blockchain Lab feeds' and is scoped to upcoming items; it says nothing about result limits, ordering, or freshness, which is minimal added context.

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

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

A single short sentence with no waste and the key scope ('upcoming') front-loaded. It is efficient, though arguably too terse to be maximally useful.

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

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

For a zero-parameter list tool with no output schema and annotations covering safety, the description is minimally adequate but leaves open what an 'event' is and how many are returned. A short clause defining the event type would close the gap with the hackathon/grant siblings.

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

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

The tool takes zero parameters, so per the baseline this dimension starts at 4. There is no parameter detail the description could add, and it correctly avoids inventing filter 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 recognizable verb+resource (listing blockchain events) and names a source ('Blockchain Lab feeds'), but 'events' is ambiguous among siblings such as list_hackathons and list_grants, and the description does nothing to distinguish this tool from those. An agent can guess the purpose but cannot confidently route between the list_* siblings.

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

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

There is no statement of when to use this tool versus alternatives like list_hackathons or list_grants, and no conditions, prerequisites, or exclusions are given. Only the implied 'upcoming' framing hints at usage.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely useful behavioral context — official links and nightly re-checking of link status — which is freshness information not available in structured fields. It does not, however, say whether the directory is paginated or filtered.

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 tight sentence with no wasted words, and the resource is front-loaded. Slightly under-specified rather than over-long, so it is concise but does little 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?

For a read-only directory tool with annotations covering safety and no output schema, the description is adequate on purpose but incomplete on the undocumented ecosystem filter and on what the listing returns. Minimum viable, with clear gaps.

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

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

There is one parameter (ecosystem) with 0% schema description coverage, and the description never mentions it or explains accepted values. The description therefore fails to compensate for the schema gap; an agent cannot tell what to pass.

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 ('blockchain ecosystem grant programmes') and implies the listing action via 'Directory of'. It is distinguishable from siblings like list_hackathons and list_events by resource, though it never states the verb or explicitly contrasts with 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?

No when-to-use guidance, no prerequisites, and no named alternatives among the many listing siblings (list_hackathons, list_events, search_whitepapers). Usage is only inferable from the resource name.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and external-source behavior are covered. The description adds genuine context by naming the upstream feeds (Devpost, ETHGlobal) and the freshness/scope filter, but says nothing about return volume, ordering, or link formats.

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 clause with zero filler; the resource leads, and provenance trails it. Nothing could be cut without losing information.

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

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

With no parameters and no output schema, the description is nearly sufficient: it establishes subject, provenance, and subset. It stops short of hinting what each hackathon entry contains (name, dates, link), which would help since no output schema exists.

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

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

The tool takes no parameters, so the baseline is 4. There is nothing for the description to disambiguate on the input side, and the schema is trivially complete.

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?

It names a specific resource (blockchain hackathons), its sources (Devpost, ETHGlobal) and the subset returned (open and upcoming), so the agent knows exactly what this returns. It does not explicitly distinguish itself from near-neighbors like list_events or list_grants, leaving the reader to infer 'hackathons' as the differentiator.

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 by the resource and scope ('open and upcoming') – there is no explicit when-to-use statement and no mention of alternatives such as list_events or list_grants. For a zero-parameter listing tool this is largely self-evident, but the description adds no 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 already declare readOnlyHint=true and openWorldHint=true, so the safety profile and external-fetch nature are covered. The description adds no behavioral context beyond that: it says nothing about ambiguous or multi-match queries, result formatting, or whether lookups are cached or rate-limited.

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

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

A single front-loaded sentence with the action first and the accepted input formats in a compact parenthetical. Every clause earns its place; nothing is padded.

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-parameter read lookup this is close to sufficient, but with no output schema the description should say what comes back (full text, metadata, URL) and it omits any explanation of the 'kind' filter. Those are real gaps for an agent deciding how to call and consume the tool.

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

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

Schema description coverage is 0%, so the description must carry the burden. It does explain the 'query' parameter well ('by number or title words' plus accepted formats like 'ERC-4337' and 'BIP-341'), but the 'kind' enum (eips/ercs/bips) is never mentioned, leaving half the parameters undocumented.

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 ('Find') and a precise resource class (Ethereum EIP/ERC and Bitcoin BIP documents), then anchors it with three concrete examples ('ERC-4337', '1559', 'BIP-341'). No sibling tool (search_whitepapers, get_chain, etc.) overlaps this function, so an agent can route to it unambiguously.

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 'by number ... or title words' implies the two ways to query, but there is no explicit when-to-use versus when-not guidance and no mention of alternatives such as search_whitepapers for broader document search. 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 declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds meaningful behavioral context beyond that: it explicitly calls the check a heuristic, names the front-run/back-run pattern it detects, requires the same EOA/bot, and bounds the search to 8 positions in the block.

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

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

Two tightly written sentences. The diagnostic question is front-loaded, and the detection criteria follow immediately with no wasted words.

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

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

For a two-parameter read-only heuristic, the description gives enough for correct invocation and interpretation of the check's scope. It does not describe the return shape or confidence/evidence output, which is a minor gap given there is no output schema.

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

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

Schema coverage is 50%: chain has a full enum description and hash is pattern-constrained but otherwise undocumented. The description uses 'this swap' and 'in the block' to imply hash is the swap transaction, but it does not explain either parameter directly, so the schema still carries most of the burden.

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

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

The description answers a specific yes/no question about a swap and then states the exact heuristic: same-pool same-direction front-run plus reversing back-run from the same EOA/bot within 8 block positions. This distinguishes it from general transaction decoders and MEV-adjacent siblings like uniswap_price_impact.

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 form implies the use case, but there is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives or when not to rely on the heuristic. It defines what the tool checks, not when an agent should choose it over decode_transaction or other investigation tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context: the data source (DefiLlama) and its nightly refresh cadence, which tells the agent the data is cached and not real-time. It does not describe return format or any 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 tight sentence with the resource and time granularity front-loaded and no wasted words. It is efficient, though the data-source parenthetical could be seen as slightly secondary 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, and the description does state the return shape (per-protocol fees plus totals) reasonably well. However, with 0% parameter coverage it omits how chain filtering and limit/pagination behave, which an agent needs to call the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden for the two parameters. It never mentions 'chain' or 'limit', leaving the agent to guess that chain scopes results and limit caps the number of protocols returned. The time windows mentioned are output dimensions, not 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 (protocol fees) with its granularity (by protocol) and time windows (24h/7d/30d) plus totals, so the agent knows exactly what data comes back. It does not, however, explicitly differentiate itself from near siblings like top_defi_protocols, chains_tvl, or dex_volumes.

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, no statement of when NOT to use it, and no named alternative among the many DeFi/TVL siblings. The agent can only infer usage from the tool name and the parenthetical time windows.

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 safe-read, external-network profile is covered. The description adds genuinely useful context by disclosing that results combine a live probe with a cached nightly snapshot, which tells the agent data may be mixed-freshness. It stops short of stating rate limits, probe timeouts, or how unreachable endpoints are reported.

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, verb first, with the measured dimensions parenthesized and the snapshot caveat trailing. Every clause carries information and there is no 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 usefully enumerates what comes back (latency, block lag, chain-ID check, snapshot), which compensates for the missing return contract. For a one-parameter read tool with annotations already covering safety and openness, this is nearly sufficient; only failure/rate-limit behavior is 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?

There is a single required 'chain' parameter with 100% schema description coverage and a closed enum, so the schema fully documents it. The description only echoes this via 'for a chain' and adds no per-chain quirks or defaults. Baseline 3 applies when the schema does the work.

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 and resource — 'Probe free public RPC endpoints for a chain' — and enumerates what is measured (latency, block lag, chain-ID check) plus the snapshot. It leaves no ambiguity about what the tool does. It does not explicitly distinguish itself from any sibling, but no sibling covers RPC probing, so the practical risk of confusion is low.

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: 'now' versus the 'nightly server-side snapshot' hints at the live-check use case, but there is no explicit when-to-use or when-not-to-use statement, and no alternative tool is named. An agent can infer intent but gets no 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 already declare readOnlyHint=true and openWorldHint=true, so safety and external-network behavior are covered. The description adds the concrete set of returned fields (owners, threshold, nonce, version), which is useful context, but nothing on rate limits, errors, or auth.

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 tight sentence, front-loaded with the verb and resource, followed by the returned fields. No waste.

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

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

For a simple two-param read tool with annotations covering safety and no output schema, the short description is adequate but thin. It doesn't clarify parameter meaning or route relative to siblings, leaving modest gaps.

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

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

Schema description coverage is 50% (chain documented in the enum description; safe has none beyond the address regex). The description echoes what fields come back but adds no semantics for the parameters themselves, leaving the 'safe' address parameter essentially unexplained.

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

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

Clear verb ('Read') and resource ('Safe (Gnosis Safe) multisig') with an explicit list of returned fields. Distinguishes itself well from siblings like safe_tx_hash, decode_safe_calldata, and inspect_address, though it doesn't name an alternative 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?

No guidance on when to use this versus siblings. An agent could reasonably wonder whether inspect_address or decode_safe_calldata covers similar ground; the description offers no routing. Only implied usage from the description.

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 readOnly and openWorld. The description adds real behavioral context beyond that: it computes locally and performs an on-chain cross-check, and it clarifies the tool's verification purpose. It still omits failure modes and the shape of the comparison result.

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 no filler; the core action is front-loaded and the verification purpose follows immediately.

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, so the description should say what is returned (the hash and/or the cross-check result), and it does not. With 7 params at 29% schema coverage and a subtle cross-check behavior, the definition leaves meaningful gaps an agent would hit at call time.

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 29% across 7 parameters, and the description supplies no parameter meaning at all (no explanation of to/value/data/operation/safe semantics or the hash fields being signed). With low coverage, the description was expected to compensate and does not.

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: compute the EIP-712 safeTxHash for a Safe transaction, and names the exact on-chain counterpart (getTransactionHash) it cross-checks against. This clearly distinguishes it from generic siblings like eip712_hash and safe_info.

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

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

Gives a concrete use case (verify what a signer should see on their hardware wallet), which tells the agent when this tool is the right choice. It does not name alternatives or exclusions versus eip712_hash or decode_safe_calldata, so it falls short of 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 already declare readOnly and openWorld. The description goes beyond them by disclosing the data source (0xB10C), update cadence (nightly), coverage limits (digital-currency addresses only, not the full SDN list), and a reliability caveat ('screening aid only'). That is meaningful context an agent cannot get from 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, front-loaded with the action and target, followed by sourcing and a caveat. 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?

Covers source, freshness, scope, and caveat, but with no output schema the description should indicate what a result looks like (match/no-match, per-address flags). That omission leaves the agent guessing about the response shape.

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 is one parameter, so the description carries some burden. It clarifies that addresses may be from 'any chain', which the untyped string array does not convey, but it says nothing about the 1-200 item bound or batch 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 (check) and resource (addresses against the OFAC SDN digital-currency address list), with explicit scope '(any chain)'. No sibling tool overlaps with sanctions screening, so the agent can immediately place it.

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

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

'Screening aid only' implies a caveat about relying on results, and the description hints at use for compliance screening, but it names no alternative tools or explicit when-not conditions. 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 already declare readOnlyHint and openWorldHint, so safety is covered. The description adds real context beyond them: corpus size (600+ papers) and the shape of the result ('metadata + original source + blockchainlab.com link'), which matters because there is no output schema. It omits pagination/default-limit behavior, which is the one notable gap for a search endpoint.

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, no waste. What it searches and what it returns are both front-loaded, so an agent gets scope and payoff immediately.

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 correctly spends its words on the return shape and corpus scope, which is what an agent needs here. It falls short only on pagination and parameter-level detail for a tool that takes a limit.

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 no param carries a description or enum, so the description must compensate. It maps reasonably well onto query/topic/year ('by text, topic or year') but says nothing about the 'limit' parameter, accepted formats, or defaults, leaving one of four params fully undocumented.

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 ('Search'), a precisely scoped resource ('Blockchain Lab's research corpus, 600+ blockchain whitepapers'), and the three search dimensions. It is unmistakably distinct from every sibling, which are all on-chain data/utility tools rather than literature search.

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

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

The description implies usage by naming the search dimensions (text, topic, year), but gives no when-to-use guidance, no prerequisites, and no exclusions or alternatives. Adequate implied guidance, nothing explicit.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read and that it queries an external source. The description adds that it uses the DefiLlama hacks DB and returns matches and total lost, which is useful context. However, it doesn't disclose pagination behavior, rate limits, or the exact shape of returned matches, which would be helpful for an open-world read.

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 waste, front-loading the resource and then the filtering options. It is efficient but slightly packed; a second sentence on return format or usage context could help without bloat.

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 5-parameter read-only tool with no output schema, the description covers the core purpose and main filters but leaves gaps: the limit parameter is undocumented, return structure is only vaguely described ('matches and total lost'), and no guidance on behavior when no results are found. It is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It names the concepts of each parameter (protocol/technique for query, date for since, min USD lost for minUsd, chain for chain) but omits limit entirely and doesn't specify formats (e.g., YYYY-MM-DD is given for dates, which is helpful). It adds meaning beyond the schema but not fully.

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: search and filter a public record of crypto hacks/exploits from the DefiLlama hacks DB. It is clearly distinct from siblings like list_hackathons or sanctions_check. It doesn't name a sibling it might be confused with, but its purpose 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?

The description implies usage (search by protocol/technique, filter by date, min USD lost, chain) but does not state when to use this tool versus alternatives like sanctions_check or a general search. No explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely useful context beyond annotations: the data source and freshness ('DefiLlama nightly'). It omits result-size/pagination behavior and whether data can be stale within the day.

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

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

Two compact sentences, front-loaded with the purpose before the filtering note, with no filler. The first sentence is dense with parentheticals but every clause carries information.

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

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

With no output schema, the description usefully enumerates the returned fields (price vs peg, mechanism, 1d/7d/30d supply change) and notes data provenance, which is what an agent needs to judge fitness. The undocumented limit parameter and lack of pagination/default-size behavior are the remaining gaps.

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

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

Schema coverage is 0% and there are 3 params. The description compensates for symbol and peg by giving concrete peg values (peggedUSD, peggedEUR), which the schema lacks as an enum, but the limit parameter is never mentioned or bounded (schema caps at 100, default unknown).

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 resource (stablecoins ranked by circulating supply) and enumerates the returned attributes: price vs peg, mechanism, and supply change windows. No sibling in the list overlaps, though the description never explicitly says whether this returns a ranked list or a single record.

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

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

The description gives filtering instructions ('Filter by symbol or peg type') but no when-to-use context, prerequisites, or boundaries (e.g., what happens with no filter, how many rows come back by default). 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 already declare readOnlyHint=true and openWorldHint=true, so the safety and network profile is covered. The description adds the compute-vs-live-read duality, which explains why the openWorld hint applies, but it does not disclose return format, auth needs, or failure behavior for the read path.

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

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

A single front-loaded sentence that leads with the verb and resource, then qualifies with the handled kinds. No filler or redundancy.

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

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

With 6 parameters, nested objects, 17% schema coverage, and no output schema, the description is too thin. It omits the semantics of most parameters and, absent an output schema, provides no explanation of what a compute or read returns.

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

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

Schema description coverage is very low (17%), so the description must compensate. It partially does by mapping the 'kind' enum values (mapping/array/erc7201) to plain-language forms and hinting at the read mode, but it says nothing about the keys, slot, index, or namespace 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?

States a specific verb ('Compute') and resource ('Solidity storage slot'), then enumerates the exact sub-kinds handled (mapping, nested mapping, array element, ERC-7201 namespace) plus an optional live read. This clearly distinguishes it from siblings like decode_calldata, abi_utils, and decode_transaction.

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 'and optionally read it live' implies a two-mode usage (compute-only vs. compute-and-read), which is useful context. However, it never states when to prefer this tool over siblings or what prerequisites/conditions select each mode, leaving usage largely to inference.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description earns credit for adding scope context: it only covers well-known spenders and top ERC-20s (not an exhaustive enumeration) and it returns actionable revoke calldata plus a Revoke.cash link. This is meaningful behavioral disclosure 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?

A single dense, front-loaded sentence using semicolons to separate the query from its two outputs. No filler, and every clause adds information.

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

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

For a two-param read tool with no output schema, the description covers what is queried and what is returned, and annotations carry the safety profile. It is largely complete, with only minor gaps around result scope/detail.

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

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

Schema coverage is 100%, with the chain enum and owner format already documented in the schema. The description adds no parameter-level detail (e.g. no note on how 'top ERC-20s' is bounded per chain), so the baseline 3 applies.

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

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

States a precise query (which well-known spenders can spend an address's top ERC-20s) plus its outputs (flags unlimited approvals, returns revoke calldata and a Revoke.cash link). The verb+resource are unambiguous and the tool is clearly distinct from siblings, though no sibling is 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?

Usage is implied (a security review of an address's token approvals) but there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named. Adequate but with clear gaps.

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, but the description adds genuinely useful provenance beyond them: the DefiLlama source and the nightly snapshot freshness, which tells an agent the data may be up to a day stale. It still omits pagination, default ordering beyond TVL, and response shape, so it stops short of full behavioral disclosure.

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

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

A single front-loaded sentence naming the resource and ranking metric first, with the filter modifiers and data source trailing as parentheticals. No sentence is wasted.

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

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

For a zero-parameter-required read tool with no output schema, the definition is workable but thin: it never says how many protocols come back by default, what fields each entry contains, or how chain/category values must be spelled. An agent can call it, but may need trial and error to get useful output.

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

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

Schema coverage is 0%, so the description must carry the load. It partially compensates by giving concrete category examples (Lending, Dexs, Liquid Staking) that the schema lacks, but 'limit' is never explained (default, max 100) and the expected format for 'chain' (slug vs. display name) is left 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 resource ('top DeFi protocols by TVL in USD'), its ranking criterion, and its data source. The word 'protocols' (versus the sibling 'chains_tvl') implicitly scopes it to a different entity class, so an agent can distinguish it from the chain-level TVL tool 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?

The description says the filters are optional but never states when to reach for this tool versus chains_tvl, nor what happens if filters are omitted. There is no when/when-not guidance or named alternative, so selection is left entirely to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real behavioral value beyond that by disclosing that this is an on-chain QuoterV2 call and enumerating the returned quantities (amount out, mid vs execution price, price impact, ticks crossed, gas estimate), which matters given there is no output schema.

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

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

A single front-loaded sentence that packs the operation and its outputs without filler. The dense output list is appropriate rather than padding, though the colon-separated enumeration reads as a fragment 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?

For a 5-parameter tool with 40% schema coverage and no output schema, the description covers the return values reasonably but leaves gaps: supported-chain behavior, token addressing, fee defaulting, and single-pool vs routed quote limitations 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 description coverage is only 40% (fee and amountIn are documented, but chain, tokenIn and tokenOut are not), so the description bears extra burden. It does not explain token address format, chain values, or that fee may default when omitted; 'single pool' only vaguely hints that pool identity 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?

The description names a specific verb and resource: an on-chain Uniswap v3 QuoterV2 quote for a single pool, and enumerates the computed quantities. It is unambiguous against siblings like bridge_quotes or dex_volumes, though it never explicitly contrasts itself with 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 phrase 'for a single pool' implies the tool is scoped to one pool rather than multi-hop routing, which is a mild usage constraint. However, there is no explicit when-to-use, when-not, or named alternative, so the agent must infer applicability.

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

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

The readOnlyHint=true annotation already establishes this is a safe, non-destructive operation. The description adds that it is a pure estimation/computation returning difficulty, attempts, time, and optionally a CREATE2 address. Beyond that it discloses nothing further (no rate limits, precision caveats), which is acceptable given it is a stateless calculation tool.

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

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

Two tight sentences with no waste, front-loading the primary estimation purpose before the secondary CREATE2 capability. Efficient and well-ordered, though the CREATE2 sentence is somewhat dense for a secondary feature.

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 names what is returned (difficulty, expected attempts, time, CREATE2 address). It covers both input modes and the read-only profile, leaving only output formatting/units and CREATE2 result details 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 must carry the load, and it largely does: 'prefix', the case-insensitive/EIP-55 toggle (mapping to caseSensitive), 'keys/s rate' (keysPerSecond), and all three create2 fields (deployer, salt, initCode) are named conceptually. It does not give value formats (0x address, salt/initCode encoding) or clarify that create2 is a nested object, leaving some gaps.

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

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

States a specific verb+resource: computing difficulty and expected attempts for an Ethereum vanity prefix, plus time at a keys/s rate. It even distinguishes the two prefix-matching modes (case-insensitive vs EIP-55) and declares a secondary CREATE2 computation. An agent immediately knows what this does, and no sibling tool overlaps this function.

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

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

The description implies the two usage modes (provide a prefix, or provide deployer+salt+initCode for CREATE2), which is enough context to select the right inputs. But it never states when to prefer this versus alternatives, nor any prerequisites or exclusions. Usage is inferred rather than instructed.

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?

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower, but the description adds no behavioral context beyond naming the scheme. It does not say what happens on an invalid signature (error vs empty result), whether the message must be plain text or hex-encoded, or what the recovered value looks like.

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 no filler; the resource standard is stated before any detail. Nothing redundant is present.

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

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

For a simple two-parameter tool with no output schema and no nested objects, the definition is near-minimal. 'Recover the signer' implies a returned address, but with no output schema an agent would benefit from knowing the failure mode and the exact encoding expectations, which are absent.

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 parameter meaning. It only alludes to the two inputs implicitly; it never specifies the signature encoding (hex with 0x prefix, r/s/v vs packed) or whether 'message' is raw UTF-8 or hex-encoded bytes before hashing per EIP-191.

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

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

States a precise verb ('Recover the signer') and a specific resource ('EIP-191 personal_sign message'). The named standard cleanly distinguishes it from siblings like eip712_hash, safe_tx_hash, and decode_calldata 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?

Usage is only implied: an agent infers this is for verifying/recovering a signer when it holds a personal_sign message plus signature. There is no explicit when-to-use note, no exclusion, and no pointer to alternatives such as eip712_hash for EIP-712 typed data.

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