Boar blockchain MCP (advanced)

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

Annotations already declare readOnlyHint and openWorldHint. The description adds the return behavior: 'Returns the hex-encoded return data', which goes beyond annotations and is useful for the agent. No contradiction with annotations.

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

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

Two sentences, front-loaded with the core action, then return data, then usage. No wasted words; 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?

For a simple call tool with no output schema, the description adequately covers purpose and return format. It does not mention revert behavior, but given the annotations and schema richness, this is acceptable. Could mention decoding with siblings but not essential.

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 does not add additional parameter semantics beyond the schema; it only mentions return data, which maps to the call data parameter but not the others.

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 'Execute a read-only smart contract call on Ethereum mainnet' which is a specific verb+resource+network. It distinguishes from siblings by specifying 'on Ethereum mainnet' and 'read-only', differentiating from mezo_call and multicall/decode variants.

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

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

Provides clear usage context: 'Use this to read contract state without sending a transaction.' This tells when to use it, but does not explicitly mention alternatives or exclusions for batch calls or decoders.

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, but the description adds valuable context: it is a 'pure computation' with no network dependency, which is not explicitly stated in the annotations. This helps the agent understand performance and dependency characteristics beyond the standard safety hints.

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

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

The description is two sentences, front-loaded with the core purpose, and each sentence adds meaningful information. There is no redundancy or filler.

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

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

For a two-parameter tool with 100% schema coverage and good annotations, the description fully covers the tool's purpose, input requirements, and execution model. It also mentions the output (function name and typed arguments), which compensates for the absence of an 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?

The input schema provides full coverage of both parameters with descriptions (calldata pattern and ABI type). The description adds a minor semantic hint ('using a provided ABI' and 'pass the hex calldata') but does not go beyond what the schema already conveys. Baseline 3 is appropriate given full schema coverage.

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

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

The description uses a specific verb ('decode') with a precise resource ('raw calldata') and clearly states the outcome ('function name and typed arguments'). It distinguishes from sibling tools by specifying 'raw calldata' and 'ABI', which differentiates it from decode_log, decode_return, decode_revert, and encode_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 clearly indicates when to use the tool (when you have raw calldata and an ABI) and highlights that it requires no RPC call, implying a lightweight alternative to eth_call. It does not explicitly name alternative tools, but the context and phrasing ('no RPC call needed') signal appropriate use cases and boundaries.

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, but the description adds meaningful behavioral detail: 'Pure computation — no RPC call needed' and 'using a provided ABI.' This clarifies that the tool does not fetch data from the blockchain and requires the caller to supply the ABI, going beyond the annotations.

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

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

The description is three short sentences, front-loaded with the core purpose, followed by essential behavioral and usage notes. Every sentence contributes meaningful information; there is no fluff or redundancy.

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

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

Given the tool's simplicity, no output schema, and good annotations, the description covers the key points: what it does, input source, and offline nature. It doesn't describe error cases or output format in detail, but those are secondary for a pure decode operation with a well-defined input. It is nearly 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 semantic context by stating that topics and data come 'from a transaction receipt log entry,' and refers to the input as 'a raw event log (topics + data).' This helps the agent understand the real-world source of the parameters, adding value over the schema alone.

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

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

The description clearly states the tool's function: decode a raw event log into named fields using a provided ABI. It specifies both the verb ('decode') and the resource ('raw event log'), and differentiates from sibling tools by explicitly mentioning 'Ethereum mainnet' and 'log' (as opposed to calldata or return).

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

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

The description provides clear context for usage: 'Pass topics and data from a transaction receipt log entry' and 'Pure computation — no RPC call needed.' This tells the agent when to use it (when raw log data is available) but does not explicitly name alternatives or exclusions, so it misses the highest bar.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds valuable context by specifying 'Pure computation — no RPC call needed', which informs the agent about execution speed and lack of network dependency. It also specifies 'on Ethereum mainnet' as a network constraint. No contradiction found.

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

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

The description is a single sentence that is concise and front-loaded. Every phrase earns its place: verb, resource, method, network, and key behavioral trait are all included without redundancy.

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

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

Given the tool's moderate complexity, the description covers the purpose, method, and key behavioral trait. The absence of an output schema is mitigated by the phrase 'into typed values', which hints at the return format. Combined with full parameter coverage and annotations, the description is sufficiently complete.

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

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

Schema description coverage is 100%: all three parameters (data, abi, function_name) have descriptive entries. The description's phrase 'using a provided ABI and function name' maps directly to parameters but adds no new meaning beyond the schema. Baseline of 3 is appropriate because the schema fully documents the 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 a specific verb ('decode'), a specific resource ('raw return data from an eth_call'), and the method ('using a provided ABI and function name'). It also names the network ('Ethereum mainnet'), which distinguishes it from mezo variants. The phrase 'Pure computation — no RPC call needed' further differentiates it from eth_call.

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

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

The description implies usage context: it is for decoding output from an eth_call, and 'no RPC call needed' suggests an alternative to calling the network. However, it does not explicitly name alternatives or state when not to use the tool. This provides clear context without explicit 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?

Beyond the readOnlyHint and openWorldHint annotations, the description adds valuable behavioral context: it is 'pure computation — no RPC call needed,' handles specific revert types (Error(string), Panic(uint256), custom errors with ABI, and silent reverts), and specifies that '0x' or empty string represents a silent revert. This gives the agent a clear understanding of what the tool does without needing to infer from annotations.

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

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

The description is a compact two-sentence structure that front-loads the core purpose. It covers the tool's functionality, supported error types, the need for ABI in custom errors, and usage context without any redundant or filler content. 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?

For a tool with moderate complexity, the description covers the essential aspects: what it decodes, input sources, special cases (silent reverts, custom errors), and the fact that no RPC call is needed. While there is no output schema, the description does not explicitly describe the return format, which might be a minor gap for an agent expecting decoded error details. However, the description is sufficient for selecting and invoking the tool confidently.

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

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

The input schema already provides 100% coverage for both parameters, with detailed descriptions for revert_data and abi. The description adds minor clarification about the source of the revert data (from a transaction receipt or eth_call response) and that custom errors require an ABI, but it largely reinforces what the schema already states. Given the high schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Decode raw EVM revert data from a failed transaction or eth_call on Ethereum mainnet.' It uses a specific verb and resource, and explicitly distinguishes from sibling tools by specifying 'Ethereum mainnet' and mentioning the types of reverts handled, which sets it apart from similar tools like eth_decode_calldata or mezo_decode_revert.

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 when to use the tool: it accepts revert data from a transaction receipt or eth_call error response, and notes that it is 'pure computation — no RPC call needed,' which implies it is appropriate when you already have the revert data and don't need to make a network call. However, it does not explicitly name alternative tools or state when not to use it, though the mainnet scope and sibling names provide implicit 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?

Annotations already include readOnlyHint=true and openWorldHint=true, signaling a safe read-only operation. The description adds 'Pure computation — no RPC call needed,' clarifying no network side effects, and warns about JS number precision loss by passing uint/int as decimal strings. This provides useful behavioral context beyond the annotations.

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

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

The description is compact and front-loaded with the purpose. Every sentence adds value: purpose, input modes, precision guidance, and the pure-computation trait. There is no fluff or redundant phrasing.

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

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

Given the tool's moderate complexity and full parameter schema, the description is complete. It explains both input modes, the output type (ABI-encoded calldata hex), and the no-RPC nature. The absence of an output schema is mitigated by the clear statement of what is returned.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including the need to pass uint/int as decimal or hex strings. The description adds a practical example and clarifies the two modes (signature vs abi+function_name), but this guidance is largely redundant with the existing parameter descriptions. It adds marginal value beyond the schema.

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

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

The description clearly states the action: 'Encode a function call into ABI-encoded calldata hex.' This verb+resource pairing distinguishes it from sibling decode tools (eth_decode_calldata) and call tools (eth_call) since it focuses on producing calldata. The example signature further clarifies the domain.

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

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

The description gives clear context: it is for encoding calldata locally, emphasized by 'Pure computation — no RPC call needed.' It explains the two input modes (signature vs abi+function_name) but does not explicitly name alternatives or exclusions (e.g., 'for decoding, use eth_decode_calldata'). This is a clear context without formal exclusions.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces the read-only nature. Beyond annotations, it discloses return format (success status and raw return data per call) and failure behavior (allowFailure prevents one failed call from aborting the batch). This adds valuable behavioral context that annotations do not cover, with no contradictions.

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

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

The description is tight and well-structured: three sentences each carrying essential information—purpose and contract address, return format, and failure-handling tip. No fluff or redundancy, and the most critical information is front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is exceptionally complete. It covers the purpose, network specificity, return behavior, and failure semantics. The absence of an output schema is compensated by explicitly stating what the tool returns. No gaps for an agent to invoke 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?

The schema fully documents the 'calls' array and its sub-fields (target, callData, allowFailure). The description adds meaning by explaining how allowFailure affects batch execution, which is not fully captured by the schema's field description. It also contextualizes the overall behavior of the batch operation. This goes beyond the schema baseline.

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

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

The description clearly states the tool's purpose: batch multiple read-only contract calls into a single RPC round trip using Multicall3 on Ethereum mainnet. It specifies the verb (batch), resource (contract calls), and mechanism (Multicall3 contract address), distinguishing it from single-call tools like eth_call and chain-specific variants like mezo_multicall.

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

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

The description implies usage context: use this when you need to batch multiple read-only calls for efficiency. It also offers specific guidance on allowFailure. However, it does not explicitly name alternatives or state when NOT to use it (e.g., for a single call or for state-changing calls). This is clear context without explicit 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 annotations already declare readOnlyHint=true and openWorldHint=true, so the description's commitment to read-only behavior is consistent. It adds the useful detail that return data is hex-encoded, but does not disclose potential revert behavior, block-tag handling, or any network-specific quirks beyond the schema.

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

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

The description is two concise sentences, front-loaded with the action ('Execute a read-only smart contract call') and then a clear outcome ('Returns the hex-encoded return data'). Every word earns its place; no wasted text or redundant repetition of the schema.

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

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

For a simple read-only call with full schema coverage and readOnly annotations, the description is mostly complete. It lacks an explicit pointer to related decode tools (e.g., mezo_decode_return) that would help the agent interpret the hex output, but this is a minor gap that does not hinder basic usage.

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

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

The input schema covers 100% of the parameters with detailed descriptions, so the baseline is 3. The tool description adds no parameter-specific meaning beyond what the schema already provides; it only mentions returning hex data, not the parameters themselves.

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

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

The description clearly states the tool executes a read-only smart contract call on Mezo and returns hex-encoded data. It distinguishes from transaction-sending tools, but does not explicitly differentiate from the very similar sibling 'mezo_testnet_call' or the generic 'eth_call' beyond the network name in the tool name.

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 'Use this to read contract state without sending a transaction' provides a clear usage context. However, it does not mention alternative tools like mezo_multicall for batching calls or the decode siblings for processing the returned data, so the guidance is useful but not fully explicit about exclusions or alternatives.

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

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

While annotations already declare readOnlyHint=true and openWorldHint=true, the description adds a key behavioral trait: 'Pure computation — no RPC call needed.' This goes beyond the read-only annotation by clarifying that no network interaction occurs. No contradiction with annotations; it complements them.

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

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

The description is three sentences with no fluff. It front-loads the main action, then adds the pure-computation note, then gives input guidance. Each sentence earns its place; 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?

For a simple two-parameter decode tool with no output schema, the description provides sufficient information: what it does, the input source, the operational nature (pure computation), and a hint of the output contents. It works well with the annotations and schema to give an agent complete guidance.

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

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

The schema covers both parameters (calldata and abi) with descriptive text, giving a baseline of 3. The description adds value for the calldata parameter by specifying its source ('from a transaction input or eth_call'), which is a meaningful hint beyond the schema's 'Raw calldata (0x-prefixed hex)'.

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

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

The description uses a specific verb ('Decode') and resource ('raw calldata'), states the output ('function name and typed arguments'), and specifies the method ('using a provided ABI') and network ('on Mezo'). This clearly distinguishes it from sibling tools like eth_decode_calldata and the testnet variants.

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 when to use the tool ('Pass the hex calldata from a transaction input or eth_call') and notes that it is pure computation with no RPC call. It does not explicitly mention alternatives or exclusions, but the context is sufficient for an agent to determine when this tool is appropriate.

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

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

Annotations already provide readOnlyHint=true, so the description's addition of 'Pure computation — no RPC call needed' gives extra behavioral context beyond annotations. It also explains the input provenance, but doesn't mention failure modes or edge cases, which is acceptable given the simplicity.

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

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

Two sentences with no filler. The first sentence states the core function, the second provides the key usage hint. Every word earns its place.

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

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

With 3 parameters, full schema coverage, and readOnly annotations, the description covers the essential context: purpose, input source, and the fact it's pure computation. It mentions 'named fields' as the output, which suffices given no output schema is present, though more detail on return format could have been added.

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

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

Schema description coverage is 100%, so the schema already fully documents topics, data, and abi. The description reinforces that topics and data come from a log entry but adds no new parameter-level meaning beyond the schema, earning the baseline score.

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

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

The description clearly states the tool decodes raw event logs (topics + data) into named fields using an ABI. It distinguishes from siblings by specifying 'event log' (vs calldata) and 'on Mezo' (vs eth/testnet variants), making 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?

Explicitly states 'Pure computation — no RPC call needed', which tells the agent this can be used offline, contrasting with RPC-dependent tools. It also advises passing topics/data from a transaction receipt log entry, giving clear input context, but does not explicitly mention alternative tools for calldata decoding.

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

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

The description adds the important behavioral detail that this is 'Pure computation — no RPC call needed,' which goes beyond the readOnlyHint annotation by confirming no network access occurs. It also clarifies it decodes 'raw return data,' implying deterministic parsing behavior. Annotations are consistent with the description.

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

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

The description is two short sentences, front-loaded with the main verb and resource. The second sentence adds the key 'pure computation' attribute 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?

The tool has a simple, well-scoped operation that is fully described: input (return data, ABI, function_name), the process (decode), and the nature (pure computation). The absence of an output schema is partially mitigated by 'typed values,' but the exact output structure is unspecified. Overall, it is adequate for the given complexity.

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

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

Schema coverage is 100%, with each parameter having a descriptive schema entry (e.g., data as 'Raw return data (0x-prefixed hex)', ABI with format details, function_name with clarification). The description restates the roles ('raw return data', 'provided ABI and function name') but does not add new semantics beyond the schema.

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

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

The description uses a specific verb ('Decode') with a clear resource ('raw return data from an eth_call') and scope ('on Mezo'), differentiating it from sibling decode tools for calldata, log, and revert. The phrase 'using a provided ABI and function name' also specifies the mechanism, making the purpose unmistakable.

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

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

The description explicitly states this tool decodes raw return data from an eth_call, which is the primary use case. It also notes 'Pure computation — no RPC call needed,' clarifying when this tool is appropriate (after obtaining return data) vs. needing to make a call. However, it does not name alternate tools or provide 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 and openWorldHint. The description adds behavioral context beyond this: handles Error(string), Panic(uint256), custom errors (requires ABI), and silent reverts. It also notes no RPC call, reinforcing the read-only nature. No contradictions.

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

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

The description is three concise sentences with zero fluff. It front-loads the core purpose, then details supported error types, operational characteristics, and input source—all 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?

Given no output schema, the description could have explained the return format, but it thoroughly covers input requirements, error types handled, and behavior (pure computation). The key usage scenarios are well addressed, though output details are implied rather than explicit.

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 value by specifying the source of revert_data (transaction receipt or eth_call error) and reiterating the ABI requirement for custom errors, which complements the schema fields.

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

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

The description clearly states the tool's function: decoding raw EVM revert data on Mezo. It specifies the resource (revert data from failed transactions/mezo_call) and distinguishes itself from sibling tools by naming the Mezo network 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?

Provides clear usage context by explaining it's pure computation (no RPC) and instructing to pass hex data from transaction receipts or eth_call errors. However, it does not explicitly contrast with alternatives like eth_decode_revert or testnet variants, though naming and 'on Mezo' imply the intended scope.

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. The description adds important behavioral details: 'Returns success status and raw return data for each call' and explains the effect of allowFailure. 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?

Three concise sentences, each adding value: purpose, return format, and a usage tip. No redundancy or fluff.

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

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

The description covers the operation, return format, and failure handling, which is sufficient for a read-only multicall tool. It doesn't mention decoding raw data, but sibling decode tools cover that. Overall quite 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 enriches understanding by explaining the purpose of allowFailure and the return format, going beyond the schema's simple parameter 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 function: 'Batch multiple read-only contract calls into a single RPC round trip via Multicall3 on Mezo'. It specifies the network, the contract, and the action, making it distinct from sibling tools like eth_multicall or mezo_testnet_multicall.

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 batching multiple read-only calls is needed, and provides a specific tip about allowFailure, but it does not explicitly compare this tool to alternatives or state when not to use it. It lacks explicit 'when to use vs. other tools' 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 description's read-only statement is redundant. It adds the useful detail that the return data is hex-encoded, but it does not disclose other behaviors such as error handling, revert behavior, or block parameter defaults. Minimal incremental value beyond annotations gives a 3.

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 short, front-loaded sentences with no unnecessary fluff. There is slight redundancy between 'read-only' and 'without sending a transaction', but it remains compact and easy to scan. It earns a 4 rather than a 5 due to the redundant phrasing.

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

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

For a simple read-call tool with full schema coverage and strong annotations, the description adequately covers purpose, return format, and usage context. It does not mention edge cases like revert behavior, but the tool's simplicity means this is not critical. Overall, it is complete enough for an agent to use correctly.

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

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

Input schema descriptions cover 100% of the parameters, including 'to', 'data', 'from', and 'block', each with clear descriptions. The tool description does not add any additional parameter semantics, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource: 'Execute a read-only smart contract call on Mezo testnet'. It clearly distinguishes from sibling tools by naming the network (Mezo testnet) and specifying read-only. The return format (hex-encoded) is also stated, which fully clarifies the tool's 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 provides clear context: 'Use this to read contract state without sending a transaction.' This tells the agent when to use the tool, but it does not mention alternatives or exclusions relative to sibling tools like mezo_testnet_multicall. Since it lacks explicit when-not-to-use guidance, it earns a 4.

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?

Discloses that this is a pure computation with no RPC call, adding valuable context beyond the readOnlyHint and openWorldHint annotations. It specifies how to obtain the input ('from a transaction input or eth_call') but does not cover error cases or ABI mismatch behavior, keeping it from a 5.

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

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

Two well-structured sentences, front-loaded with the main purpose and no redundant information. Every phrase earns its place.

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

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

For a simple two-parameter tool, the description covers the purpose, network, and input sources. It partially specifies the output ('function name and typed arguments') but lacks details on failure modes or output structure, which would be useful since no output schema is provided.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minor context about the calldata source ('from a transaction input or eth_call') but does not substantially enhance what the schema already documents for the abi and calldata 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 verb 'Decode', the resource 'raw calldata', and the output 'function name and typed arguments', while specifying the context 'on Mezo testnet'. This distinguishes it from sibling tools like eth_decode_calldata and mezo_decode_calldata by network and input 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?

It provides clear usage context by stating 'Pass the hex calldata from a transaction input or eth_call' and emphasizes 'Pure computation — no RPC call needed'. However, it does not explicitly mention alternatives or exclusion criteria, so it misses the top score.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds value by stating 'Pure computation — no RPC call needed', which clarifies that no network interaction occurs and results are deterministic. It also indicates the input comes from transaction receipt logs, adding context beyond the annotations. There is no contradiction.

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

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

The description is two sentences, with the first sentence stating the core purpose and the second providing a key behavioral note. It is concise, front-loaded, and contains no filler words. 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?

The tool is a decode function with well-documented parameters and annotations covering safety. The description explains the input source and pure-computation nature, which is sufficient for an agent to understand the tool's role. There is no output schema, but the phrase 'into named fields' gives a basic expectation. It lacks explicit details about output structure or error handling, but this is acceptable given the established pattern of decoder tools.

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

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

The input schema already provides detailed descriptions for all three parameters, including topics[0] as event signature hash, data as non-indexed parameters, and abi as JSON array or string. The description's mention of 'topics and data' adds no new semantic detail beyond the schema. Since schema coverage is 100%, a baseline of 3 is appropriate.

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

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

The description clearly states the tool decodes raw event logs using topics and data, with a provided ABI, on Mezo testnet. It distinguishes itself from sibling decode tools by specifying the network (Mezo testnet) and the specific input type (event logs). The verb 'decode' and resource 'raw event log' are specific and 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 provides guidance on when to use it: 'Pass topics and data from a transaction receipt log entry' and notes 'pure computation — no RPC call needed'. This implies it should be used when you have a log entry from a receipt and want a decoded result without network calls. However, it doesn't explicitly compare with alternatives like eth_decode_log or mezo_decode_log, but the network-specific name and context make the intended usage clear.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds a valuable behavioral detail: 'Pure computation — no RPC call needed.' This goes beyond the annotations by clarifying no network interaction occurs, which is useful for an agent deciding between this and call-based tools.

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 action and scope, with the second sentence adding a crucial behavioral distinction. Every word earns its place; no fluff or redundancy.

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

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

For a simple decode tool with three well-documented parameters and strong annotations, the description is complete. It conveys the input data, the role of ABI and function name, and the output type ('typed values'). No output schema exists, but the description sufficiently indicates what the tool returns without over-explaining.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters fully. The description's mention of 'provided ABI and function name' paraphrases the schema without adding new meaning. It does not compensate for any gaps because there are none, but it also adds no extra semantic value beyond the schema.

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

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

The description clearly states a specific verb+resource ('Decode raw return data from an eth_call') and specifies the network scope ('on Mezo testnet'). It also distinguishes from sibling tools by noting this is pure computation (no RPC call), separating it from call tools and other decode tools (calldata/log/revert).

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

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

The description gives clear context for when to use the tool: when you have raw return data and want typed values, without making an RPC call. It implies this is the offline decoding tool for Mezo testnet, but it does not explicitly name alternatives (e.g., mezo_decode_return for mainnet) or state when not to use it.

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

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

The description adds useful behavioral detail beyond the annotations: it states 'Pure computation — no RPC call needed,' and outlines the specific revert types handled (Error(string), Panic(uint256), custom errors, silent reverts). This gives the agent a clear model of the tool's capabilities and limitations, complementing the readOnlyHint and openWorldHint annotations.

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

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

The description is four sentences, all information-dense and free of filler. It front-loads the primary purpose and then layers capabilities and usage details efficiently. No sentence is redundant or unnecessary.

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 decode tool with two parameters and no output schema, the description is quite complete: it explains what it decodes, the supported error types, the input requirements, and the pure computation nature. The only minor gap is that it does not explicitly describe the return format, but this is not critical given the tool's straightforward purpose.

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

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

The schema already has 100% parameter coverage, and the description adds practical context by telling the user to 'Pass the hex revert data from a transaction receipt or eth_call error response,' which clarifies where the required parameter comes from. It also ties the optional 'abi' parameter to the handling of custom errors, adding meaning beyond the schema's basic 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 function: 'Decode raw EVM revert data from a failed transaction or mezo_testnet_call on Mezo testnet.' It uses a specific verb (decode) and resource (revert data), and the mention of 'Mezo testnet' distinguishes it from sibling tools like eth_decode_revert and mezo_decode_revert.

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

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

The description provides clear context for when to use the tool: when you have raw revert data from a failed transaction or eth_call error response. It also notes that it is 'Pure computation — no RPC call needed,' which helps differentiate it from RPC-requiring tools. However, it does not explicitly exclude alternatives or name sibling tools, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description builds on that by adding behavioral details: it returns per-call success status and raw data, and explains how allowFailure prevents batch abort. This exceeds the baseline and provides useful operational context beyond the annotations.

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

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

Three compact sentences front-load the primary purpose, then provide address and return format, and finally a failure-handling hint. Every sentence adds value with no redundancy or filler.

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

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

Given the lack of an output schema, the description covers the essential return structure (success status and raw data). It also specifies the network, contract address, and failure behavior. It could be slightly more complete by mentioning when to prefer a single-call tool, but it is largely 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%, so the description adds minimal parameter-level meaning. The allowFailure behavior is already documented in the schema, and the description simply reiterates it without new syntax or edge-case details. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Batch') with a clear resource ('multiple read-only contract calls') and differentiates the tool by specifying Multicall3 on Mezo testnet with the contract address. It clearly states the output (success status and raw return data), distinguishing it from sibling tools like eth_multicall or single-call tools.

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

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

The description clearly implies the tool is for batching independent read-only calls on Mezo testnet to reduce RPC round trips. It provides a concrete usage hint for allowFailure but does not explicitly name alternatives or state when not to use it (e.g., for state-changing calls or for mainnet).

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