tenzro-ethereum

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

The description labels the tool as 'read-only', indicating no state changes, and notes it 'Returns the raw hex result'. With no annotations provided, this disclosure is adequate. It does not contradict any structured fields.

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

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

Two concise sentences front-load the core purpose and parameters, with no superfluous text. Every sentence adds value.

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

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

Given the tool's simplicity, an output schema exists, and the description covers purpose, parameters, return type, and a reference to a related tool, making it fully adequate for selection and 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 coverage is 100%, so baseline is 3. The description lists parameters and adds context (default block 'latest'), but does not add significant meaning beyond the schema's own descriptions.

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

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

The description explicitly states 'Execute a read-only eth_call against a smart contract', identifying the action, resource, and nature (read-only). It distinguishes itself from sibling tool eth_encode_function by referencing it for calldata preparation.

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

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

The description provides clear guidance to use eth_encode_function to build calldata, implying when this tool is appropriate. However, it does not explicitly mention when not to use it or contrast with alternatives like eth_estimate_gas.

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

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

With no annotations, the description fully explains the encoding algorithm: Keccak-256 for selector, left-padding of args to 32 bytes. It also provides an example. It does not mention error cases, but the behavior is well-disclosed for a pure computation tool.

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

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

The description is three sentences: purpose, algorithm, and example. It is front-loaded and contains no extraneous information.

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

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

The description is sufficient for understanding the tool's behavior and output, given the schema covers parameters and an output schema likely describes the return value. It covers the encoding process and provides an example. It could mention support for dynamic types or validation, but overall complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds an example and process context, but does not add new parameter-level meaning beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'ABI-encode a function call.' It explains the output is hex-encoded calldata ready for eth_call or a transaction, which distinguishes it from sibling tools that execute calls or estimate gas.

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

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

The description implies usage when preparing calldata for eth_call or transactions, but does not explicitly contrast with alternatives like eth_call_contract or provide when-not-to-use guidance.

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

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

With no annotations, the description carries full burden. It states the return format (decimal and hex) but doesn't disclose that it's a read operation, potential cost, or that estimates may vary.

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 efficient sentences: first states purpose, second lists params and return. No extraneous information.

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

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

For a simple tool with high schema coverage and an output schema, the description is nearly complete. Could mention it's a simulation (no on-chain effect) but still adequate.

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

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

Schema coverage is 100%, so description adds little beyond repeating which parameters are required/optional. No additional constraints or usage details beyond schema.

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

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

The description clearly states the tool estimates gas for a transaction via eth_estimateGas, which is a distinct purpose from siblings like eth_get_gas_price or eth_get_fee_history.

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

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

The description lists required and optional parameters but does not specify when to use this tool versus alternatives or provide any guidance on prerequisites or context.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool posts a GraphQL query to an external indexer (easscan.org) and lists returned fields. This provides sufficient behavioral context for a read-only query, though it could mention any network dependency or potential latency.

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

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

The description consists of two short, information-dense sentences. The first states purpose and action, the second details return content. Every word earns its place; no filler or redundancy.

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

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

Given the tool's simplicity (one parameter, output schema exists), the description covers essential aspects: what it queries, how it queries, and what it returns. It could mention that the output schema contains the listed fields, but this is implied. No major 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?

The input schema has 100% description coverage for the single parameter (uid), describing it as 'Attestation UID (bytes32 hex, with or without 0x prefix)'. The tool description repeats this but adds no new semantic information beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool queries an EAS attestation by UID, using a specific verb ('Query') and resource ('attestation from Ethereum Attestation Service'). It differentiates from sibling tools (e.g., eth_get_block, eth_get_transaction) by focusing on EAS attestations, which no other sibling covers.

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

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

The description provides clear context on what the tool does (query an attestation) and how it works (posts GraphQL to easscan.org). However, it does not explicitly state when not to use it or mention alternatives among siblings, which are all distinct enough that confusion is unlikely.

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

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

No annotations are present, so the description carries full burden. It discloses output format (three units) but lacks details on caching, error handling, or address checksum requirements. Schema covers parameters, but behavioral aspects beyond that are minimal.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds value, stating purpose and output.

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

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

For a simple tool with output schema and good parameter docs, the description covers core functionality. It could mention block parameter behavior, but schema handles that. Overall complete for typical use.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides. It mentions output units but 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 clearly states the tool fetches ETH balance for an address via eth_getBalance, and specifies it returns balance in three units (wei, Gwei, ETH). This distinguishes it from sibling tools like eth_get_token_balance.

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

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

The description does not explicitly guide when to use this tool versus alternatives, but the tool's name and sibling list imply it's for native ETH balance. No when-not-to-use or alternative suggestions are provided.

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

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

The description discloses that the tool returns 'block header, transactions, and metadata', which explains the output beyond the schema. It also names the underlying RPC method, hinting at its read-only nature. However, it does not mention potential performance concerns with full_transactions or any rate limits. With no annotations, this is good but could be improved.

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

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

The description is extremely concise: two sentences that first state the purpose and method, then summarize parameters and return. Every sentence adds value, and the structure is front-loaded with the most critical information. No redundant or vague wording.

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

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

Given that the input schema is complete and there is an output schema (mentioned), the description adequately covers the essentials. It states what the tool does, its parameters, and the nature of the response. For a simple read-only tool, this is mostly sufficient; a minor gap is the lack of any note about block size or error conditions.

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

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

The input schema already provides full descriptions for both parameters (block_number and full_transactions) with types, defaults, and meaning. The description merely summarizes these without adding new insight. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'block by number'. It includes the specific RPC method 'eth_getBlockByNumber', which precisely identifies the action and distinguishes it from other Ethereum tools like eth_get_transaction or eth_get_balance.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The usage is implied: call it when you need block data by number. No when-not or contextual hints are given.

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

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

No annotations are provided, so the description must convey behavior. It states the tool 'Get fee history', implying a read-only operation, and lists three return fields. It does not describe potential limitations (e.g., maximum block count, rate limits) or side effects, but for a simple read operation it is suitably transparent.

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

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

The description is extremely concise—two sentences that immediately state the action and returned data. No filler or redundant phrases; every word adds value.

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

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

Given the presence of an output schema (not shown but noted), the description need not detail return values. It already lists the key return fields and ties them to EIP-1559 estimation. It lacks notes on edge cases or typical usage limits, but is adequate for a straightforward 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 description coverage is 100% with each parameter having a concise explanation (e.g., default values, expected formats). The tool description adds no additional parameter information beyond what the schema already provides, meeting baseline but not exceeding.

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

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

The description clearly states the tool retrieves fee history via eth_feeHistory, explicitly listing the returned data (base fees, gas used ratios, reward percentiles) and its use for EIP-1559 gas estimation. This distinguishes it from siblings like eth_get_gas_price (single gas price) and eth_estimate_gas (gas estimation for a specific 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 description implies usage for EIP-1559 gas estimation but provides no explicit guidance on when to use this tool versus alternatives like eth_estimate_gas or eth_get_gas_price. No exclusions or when-not-to-use examples are given, limiting agent decision support.

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

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

No annotations are provided, so the description must carry the full burden. It only states the return format but does not disclose that this is a read-only call with no side effects, nor any potential costs or network dependencies.

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 concise sentences, front-loaded with the main purpose and additional details in the second sentence. No redundant or vague phrasing.

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

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

For a simple input-less tool with an output schema, the description is mostly adequate. It covers return values, but lacks context on when to use versus siblings or any behavioral notes. The output schema exists, so the description focuses appropriately on usage rather than return structure.

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

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

The tool has zero parameters with 100% schema coverage, so the schema already conveys the absence of inputs. The description adds value by detailing the return format (wei, Gwei, hex), which is not in the schema.

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

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

The description clearly states the tool gets the current gas price via eth_gasPrice JSON-RPC and specifies the output units (wei, Gwei, hex). It uses a specific verb-resource pair and distinguishes from sibling tools like eth_get_fee_history.

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

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

No guidance on when to use this tool versus alternatives (e.g., eth_get_fee_history for more detailed fee data). No prerequisites or exclusions are mentioned.

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

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

Without annotations, the description carries the full burden. It discloses that the tool calls latestRoundData() on a Chainlink feed, returns price with 8 decimals, round ID, and timestamps. However, it doesn't mention potential errors (e.g., invalid feed address) or that it is a read-only call (no destructive side effects), which would be important for a complete behavioral profile.

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

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

Two sentences, no filler. Front-loaded with the main action ('Get token price from a Chainlink AggregatorV3Interface data feed'). Every sentence adds essential information without redundancy.

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

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

Given 2 optional parameters, an existing output schema (external to this definition), and no annotations, the description covers the essential behavior, defaults, and return fields. It could mention that feed_address must be a valid aggregator address, but overall it is complete enough for most use cases.

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 have schema descriptions covering types and defaults. The description adds value by clarifying the default feed address, the chain IDs that map to specific dRPC URLs, and that chain_id defaults to 1 (mainnet). This goes beyond the schema's bare descriptions.

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

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

The description clearly states the tool gets a token price from a Chainlink aggregator via eth_call to latestRoundData(). It specifies the default feed, precision, and return fields. This distinguishes it from sibling tools like eth_call_contract that could be used for arbitrary contract calls.

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

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

No guidance on when to use this tool versus alternatives like eth_call_contract for custom price fetching. The description does not mention prerequisites or when not to use it, leaving the agent without explicit selection criteria.

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

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

Describes use of eth_call (read-only) and return format (raw balance, caller divides). No annotations provided, so description carries burden. Missing details like error cases or permission needs, but adequate for a simple query.

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 concise sentences, front-loaded with purpose, no superfluous content.

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

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

Explains return processing (divide by 10^decimals). With output schema present and simple parameters, description is mostly complete. Could mention how to obtain decimals.

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

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

Schema coverage is 100% with descriptions. Description merely restates schema fields without adding extra meaning (e.g., format constraints or relationship). Baseline 3.

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

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

Clearly states verb 'Get' and specific resource 'ERC-20 token balance for an address', plus mechanism 'via eth_call to balanceOf(address)'. Distinguishes from sibling tool eth_get_balance for native ETH.

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

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

Implies use case (retrieve ERC-20 token balance) but lacks explicit 'when not to use' or alternatives. However, context signals and sibling list provide enough differentiation.

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

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

With no annotations, the description fully bears the burden of behavioral disclosure. It states the return fields but does not mention idempotency, error cases (e.g., invalid hash), rate limits, or side effects. For a read-only operation, transparency is adequate but not thorough.

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

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

The description is two sentences: one for the action and one for the return values. It is concise, front-loaded, and contains no unnecessary words.

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

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

Given that an output schema exists, the description adequately covers the tool's purpose and return data. It could mention error handling or prerequisites, but it is sufficiently complete for a simple 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?

The input schema already describes the only parameter (tx_hash) with 100% coverage. The tool description adds no extra meaning or constraints beyond listing return fields, so it provides minimal value over the schema.

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

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

The description clearly states it retrieves transaction details by hash and lists the returned fields. However, it does not explicitly differentiate from sibling tools like eth_get_transaction_receipt, though the mention of the specific JSON-RPC method 'eth_getTransactionByHash' provides some 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 description does not provide any guidance on when to use this tool versus alternatives, such as when to use eth_get_transaction_receipt or other related tools. It only implies usage for transaction lookup by hash.

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

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

With no annotations, the description carries full burden. It correctly notes the read-only nature (no side effects) and lists return fields. However, it does not disclose potential error conditions (e.g., hash not found), rate limits, or that receipts are only available for mined transactions.

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

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

Two sentences, front-loaded with action and result, every word earns its place. No redundancy or extraneous detail.

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

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

For a simple 1-parameter read tool with an output schema, the description covers the main return fields. It could mention that the receipt may be null for unconfirmed transactions, but overall sufficient.

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

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

Schema coverage is 100% for the single parameter tx_hash, whose description already states it's a hex string with optional 0x prefix. The tool description adds no additional semantic info beyond 'by hash', so no extra value over schema.

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

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

The description clearly states the verb 'Get' and resource 'transaction receipt by hash', and lists specific return fields (status, gas used, logs, contract address, block info). It is specific and actionable, but does not explicitly differentiate from siblings like eth_get_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?

No guidance on when to use this tool versus alternatives such as eth_get_transaction or other receipt-related tools. The description does not mention prerequisites, excluded cases (e.g., pending transactions), or preferred contexts.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool builds calldata (not executes) and selects the appropriate function based on input type. However, it does not describe error handling or output format, though the output schema exists separately.

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

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

The description is two sentences with clear front-loading of purpose. It is efficient, but could be slightly more structured (e.g., separating purpose from usage). Overall, it is concise and effective.

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

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

Given the simple parameter structure and presence of an output schema, the description covers the core functionality (lookup and calldata building) well. It does not explain the output schema, but that is provided separately, so completeness is adequate.

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

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

With 100% schema coverage, baseline is 3. The description adds value by specifying the underlying smart contract functions (getAgent or getAgentsByOwner) and the dual nature of the parameter (ID or address), which enriches understanding beyond the schema description.

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

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

The description clearly states the tool looks up an AI agent in the ERC-8004 registry by agent ID or owner address. It specifies the resource (agent in registry) and action (look up), and distinguishes itself from sibling tools like generic eth_call_contract or eth_lookup_ens.

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

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

The description mentions the tool builds calldata for use with eth_call_contract, implying a usage pattern. However, it lacks explicit when-to-use or when-not-to-use guidance, and does not compare to alternatives like using eth_encode_function directly.

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?

Describes the on-chain mechanism and fallback to OnchainKit API, adding behavioral context beyond a simple reverse lookup. Missing details on error handling or prerequisites, but output schema exists.

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

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

Two sentences, front-loaded with purpose, no filler. Efficiently conveys key information: what it does, how it works, and parameter summary.

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 core behavior and mechanism adequately. With an output schema present, missing error handling or network requirements are minor omissions for a straightforward 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 coverage is 100% and the description mostly restates the schema's parameter description. Does not add significant new meaning beyond what's already in the structured field.

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

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

Clearly states the tool does a reverse lookup of an Ethereum address to its ENS name, specifying the method (Universal Resolver) and distinguishing from sibling tools like eth_resolve_ens for forward lookups.

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?

Implicitly distinguishes from forward lookup via 'reverse-lookup' keyword, but lacks explicit when-not or alternative tool comparisons. However, given sibling names, the purpose is clear enough.

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

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

No annotations are provided, so the description carries the full burden. It states that the tool builds transaction data (not sends it) and returns ABI-encoded output. This implies no side effects, but it could explicitly declare read-only behavior. The disclosure is sufficient for safe use.

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

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

The description is three sentences, front-loaded with purpose, and contains no fluff. Every sentence provides essential information.

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

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

An output schema is indicated to exist (though not shown), so the description does not need to detail return format. It mentions 'ABI-encoded function selector and parameter breakdown,' which is adequate. The tool's input parameters are fully explained in the schema.

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

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

Schema coverage is 100% (baseline 3). The description adds value by mapping parameters to the function signature 'registerAgent(string,string[],string)' and describing metadata_uri as 'IPFS or HTTPS URI', which goes beyond the schema description.

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

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

The description clearly states the tool's purpose: 'Build transaction data for registering an AI agent via ERC-8004 Agent Registry.' It specifies the verb (build transaction data) and resource (ERC-8004 registry), and distinguishes from siblings like eth_lookup_agent_8004 which handles lookups.

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

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

The description mentions that the caller must sign and submit the transaction, implying a prerequisite, but does not explicitly state when to use this tool versus alternatives or provide when-not-to-use guidance. While sibling names offer context, the description itself lacks exclusions.

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

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

The description discloses the resolution process: tries on-chain via eth_call to a specific contract, then falls back to an API. This provides substantial transparency beyond a simple statement.

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

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

The description is three sentences, front-loaded with the main action, and contains no unnecessary words.

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

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

For a simple ENS resolution tool with one parameter and an output schema, the description covers the functional behavior, parameter, and method details adequately.

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

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

Schema coverage is 100%, and the description adds an example but does not significantly augment the schema description. Baseline 3 is appropriate.

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

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

The description explicitly states it 'Resolves an ENS name to an Ethereum address' with specific details about the resolver method and fallback, clearly distinguishing its purpose from siblings like eth_lookup_ens.

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

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

The description implies usage for resolving ENS names but does not provide explicit guidance on when to use this tool versus alternatives like eth_lookup_ens.

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

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

No annotations provided, so the description carries the full burden. It discloses that the return is plain text (the transaction hash) but lacks mention of potential failures (nonce errors, insufficient funds), side effects (nonce consumption, broadcast idempotency), 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?

Two sentences with no wasted words. First sentence states purpose and return; second details parameter and build process. Front-loaded and efficient.

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

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

For a simple one-param tool with full schema coverage, the description covers purpose, parameter, and return. However, the lack of behavioral transparency for a write operation reduces completeness. Edge cases and failure modes 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 coverage is 100%. The description adds value beyond the schema by noting that the hex can be with or without 0x prefix, and clarifies the build process using helpers. This exceeds what the schema alone provides.

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

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

The description clearly states 'Broadcast a pre-signed Ethereum transaction via eth_sendRawTransaction', identifying the verb (broadcast) and resource (pre-signed transaction). It distinguishes from sibling tools which are primarily read or encoding/estimation operations.

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

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

Provides explicit guidance on building the raw_tx using eth_encode_function, eth_estimate_gas, and an external signer or tenzro_signTransaction. It implies when to use (after signing) but does not explicitly exclude use cases or state when to use sibling alternatives.

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