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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious behavior: a per-token failure is surfaced in that token's entry rather than failing the whole call, which is important for an agent parsing partial results.

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

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

Two short sentences, zero waste. The core capability is front-loaded and the partial-failure caveat follows immediately where it is most relevant.

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

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

An output schema exists, so return structure need not be explained, and the description usefully covers the one non-obvious output behavior (per-token errors). It is slightly thin on whether 'block' applies to both native and ERC-20 reads, and on the meaning of 'HYPE' for a non-chain-expert agent.

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

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

Schema description coverage is 100%, so the schema already documents address, block (including tags) and the max-20 tokens array. The description only reinforces that token balances are optional and that failures are isolated; it adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Native HYPE balance of an address') and adds the scope extension of optional ERC-20 balances. It does not, however, name or exclude any sibling such as get_token_info or read_contract, so sibling disambiguation is left to inference.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The description never says how this differs from read_contract or get_token_info, or when the optional tokens list should be supplied versus a separate token query.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered. The description's added value is noting the two return modes (hashes vs full transactions), which is mildly useful context but partially redundant with the includeTransactions parameter and the output schema.

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

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

Two compact sentences, front-loaded with the purpose and identifier forms, with the return behavior appended. No filler or repetition.

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

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

With a full parameter schema, an output schema, and rich annotations, the description covers the essentials an agent needs to invoke the tool. The only real omission is usage routing against siblings, which is a minor gap given how specific the verb and resource are.

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 both parameters are already documented in detail (block accepts number/hash/tag with defaults; includeTransactions controls verbosity). The description restates the identifier forms the schema already covers and adds no new syntax, formatting, or edge-case guidance.

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

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

The description names a specific verb (fetch) and resource (block), enumerates the three accepted identifier forms (number, hash, tag), and states the return shape (header fields plus transaction hashes or full transactions). This clearly separates it from siblings like get_transaction or get_logs without needing to name them.

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

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

There is no explicit guidance on when to call this versus alternatives such as get_transaction or get_chain_status, nor any stated prerequisites or exclusions. The only situational hint — that an unspecified block defaults to latest — lives in the schema, not the description.

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

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

Annotations already declare readOnly, idempotent, open-world and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond them: block time is a *measured* average over a recent window, and the one-second timestamp resolution combined with multi-block-per-second production means a single block's delta would be misleading. That is a meaningful caveat about the precision of a returned metric.

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 returned metrics, and the second sentence exists solely to explain why block time is windowed. Nothing is repeated from the schema and no sentence is filler.

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

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

An output schema exists, so return values need not be enumerated, and an output schema plus full schema coverage means the one parameter is covered. For a simple read-only status tool the description supplies enough; only the when-to-use framing is absent.

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

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

Schema description coverage is 100% and the single optional sampleSize parameter is fully documented in the schema, including its default (BLOCK_TIME_SAMPLE_SIZE = 1000). The description only alludes to 'a window of recent blocks' without adding format, bounds, or tuning advice beyond the schema, so the baseline 3 applies.

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

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

The description names the concrete payload — latest block, measured average block time, current base fee and gas price — which is a specific resource distinct from sibling tools like get_block or get_transaction. It never explicitly names a sibling to route against, but an agent can tell this is chain-wide aggregate status rather than per-block or per-tx detail.

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

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

There is no statement of when to prefer this over get_block or get_logs, no exclusions, and no prerequisites. Usage is only inferable from the returned-fields list, so an agent must guess whether this is the right entry point for chain health versus pulling a specific block.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the bar is lower. The description goes beyond them by disclosing the range cap (MAX_LOG_BLOCK_RANGE, default 2,000, ~3-7 min on Elysium), the 10,000-log-per-query ceiling, and the mitigation (split ranges or add filters) – concrete limit behavior the annotations do not convey.

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

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

Three sentences, front-loaded with the core action, then filtering options, then the constraint/limit caveat. No filler; each sentence adds operative 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 exists, so return values need not be explained. Combined with annotations carrying the safety profile, the description covers action, filtering, and limits fully enough for an agent to invoke correctly.

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

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

Schema coverage is 100%, so a 3 baseline is warranted, but the description adds meaningful relational semantics: address filtering plus the choice between an event signature (with optional indexed-argument values) or raw topics. This clarifies the event/args-vs-topics alternative beyond the per-property schema text.

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

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

States a specific verb (Query) and resource (event logs) with a clear scope (over a block range) plus the two filtering mechanisms (address + event signature/args, or raw topics). It is distinguishable from siblings like get_transaction and get_block by resource, though it never explicitly names a sibling to route against.

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 operational guidance on how filtering changes the allowed range and how to react to the 10,000-log cap, which is genuinely useful when-usage context. However, it never names an alternative (e.g., read_contract or get_transaction) or states when a different tool would be preferable, so routing guidance is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description usefully adds one edge-case behavior – unimplemented fields return null – but says nothing about failure modes for invalid/non-contract addresses or reverts.

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

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

Two tight sentences, front-loaded with the purpose and followed by the one behavioral caveat. Every clause earns its place with no filler.

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

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

With an output schema present, return values need no explanation, and annotations fully cover the read-only safety profile. For a two-parameter read tool this is 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%, so both the token address format and the block parameter (with its tags) are fully documented in the schema. The description adds no parameter meaning beyond that, making the baseline 3 correct.

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

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

States a specific verb (Read) and resource (ERC-20 token) and enumerates exactly which fields are returned: name, symbol, decimals, total supply. This clearly distinguishes it from the generic sibling read_contract, letting an agent pick the right tool without opening schemas.

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

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

Usage is only implied by the ERC-20 specialization; the description never says when to prefer this over read_contract or what happens for non-ERC-20 contracts. No explicit when-not or alternative routing is 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: pending transactions return a null receipt, and systemTransaction flags ArbOS type-106 bookkeeping txs that pay no fee — semantics an agent could not infer from 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?

Front-loads the core action in the first sentence, then layers conditional behavior. Each sentence carries information, though the closing systemTransaction clause is long and reads more like a doc footnote than selection guidance.

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

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

With an output schema present, return values need not be enumerated, and the description still covers the two edge cases an agent would otherwise misread — pending txs and system transactions. Combined with annotations, nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, so both hash and abi are already documented in the schema. The description reinforces the ABI effect (decodes input data and event logs) but adds no syntax or format detail beyond the schema's own examples. Baseline 3 applies.

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

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

States a specific verb and resource ('Fetch a transaction and its receipt by hash'), and the retrieval key is named, which distinguishes it from siblings like get_block and get_logs. An agent knows exactly what it retrieves and by what identifier.

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

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

Usage is implied by the name and scope (look up a tx by hash), and the conditional ABI-decoding behavior hints at when to supply that parameter. However, there is no explicit when-to-use vs alternatives guidance, e.g. when to prefer get_logs or get_block, nor any statement of preconditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the bar is lower. The description reinforces this with 'Nothing is sent to the chain' and adds that the result is decoded, giving useful behavioral context beyond the flags, though it lacks detail on failure/call-revert behavior.

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

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

Three short sentences with zero filler; the functional statement is front-loaded and the routing note follows immediately. Every sentence earns its place.

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

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

An output schema exists, so return-value explanation is unnecessary, and rich annotations plus full schema coverage cover the structured fields. For a read-only call tool, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so all five parameters (abi, args, block, address, functionName) are already documented in the schema. The description adds no further parameter meaning such as argument coercion or block-tag nuances, so the baseline of 3 applies.

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

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

States a specific verb (call), resource (view or pure function on a contract), and outcome (decoded result), which is unambiguous. It also distinguishes itself from the sibling simulate_call by name, so an agent can route without opening either schema.

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

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

Explicitly specifies the condition for using the alternative: 'For state-changing functions, use simulate_call.' This gives a clear when-to-use / when-to-use-something-else rule rather than leaving it to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: it is a dry run that sends nothing, it estimates gas, and a failing transaction returns success:false with the revert reason rather than a tool error. That failure-mode disclosure is valuable and not present in 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 tight sentences, front-loaded with the core action ('Dry-run a transaction ... without sending anything'). Every sentence carries information: scope, input modes, failure semantics. No filler.

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

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

With an output schema present, the description does not need to explain return values, and it already covers the critical non-obvious return behavior for reverts. Annotations cover the safety profile. The one omission is routing relative to similar sibling tools like read_contract, which would help an agent pick correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; the individual params are already well documented. The description adds orchestration semantics the schema can't express cleanly: the two mutually exclusive input modes (raw data vs. abi + functionName + args) and the fact that the latter causes encoding and result decoding.

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

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

States a specific verb and resource: dry-run a transaction with eth_call, estimate gas, and do not send. This is far more precise than a tautology, and the no-send scope distinguishes it from a real transaction submission. However, it never names or contrasts with the similar sibling read_contract, so an agent must infer the boundary.

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

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

The description implicitly defines when to use it ('dry-run ... without sending anything') and documents the two input modes (raw data vs. abi+functionName+args). But it does not explicitly say when to choose this over read_contract or get_transaction, nor does it state any exclusions or prerequisites.

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