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 return type ('hex data string') and the underlying implementation (viem encodeFunctionData), but does not state that it is a pure, side-effect-free local computation, nor what happens on invalid ABI/args. Adequate but incomplete for an unannotated 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?

Four short sentences, front-loaded with purpose and ending with the usage cue. Slightly redundant, since 'Uses viem encodeFunctionData' largely restates 'Encode function call data from ABI,' but overall tight.

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 3-parameter, fully documented, non-mutating utility with no output schema, the description covers purpose, inputs, return format, and usage. Missing only edge-case/error behavior, which is minor here.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description only echoes the parameter list ('ABI, function name, and optional args') without adding syntax, ordering, or format detail beyond what the schema provides. Baseline 3 is 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 (Encode) and resource (function call data) and enumerates the inputs (ABI, function name, optional args). It is clearly distinguishable from the read-oriented siblings, though it does not name any sibling 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?

'Use for building transaction calldata' gives a clear when-to-use context, but there are no exclusions, prerequisites, or named alternatives (e.g., when to use read_contract vs this). Guidance is implied rather than explicit.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses the return shape (estimated gas, optionally KAIA at current gas price) and the contract-creation case for an omitted 'to', but says nothing about whether this is a read-only simulation, node/network requirements, or failure modes.

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

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

A single efficient sentence with the core purpose and return value front-loaded, followed by an inline parenthetical on inputs. It wastes little, though the parenthetical and the return clause are somewhat compressed.

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

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

For a simple gas-estimation tool with full schema coverage and no output schema, the description covers purpose, inputs, and return values adequately. The remaining gap is behavioral (read-only nature, network/state assumptions), which keeps it just short of 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 all five parameters are already documented in the schema. The description restates from/to/value/data but adds only minor meaning (contract creation when 'to' is omitted) and omits the network parameter entirely, so it stays at the baseline for a fully documented 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 gives a specific verb (estimate) and resource (gas) scoped to a transaction, with the input fields enumerated. It is clear what the tool does, but it never names or contrasts with the sibling get_gas_price, which is the nearest adjacent concept, so differentiation 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?

Usage is implied rather than stated: a reader infers this is called before sending a transaction to preview cost. There is no explicit when-to-use/when-not guidance and no mention of the get_gas_price alternative, so the agent must reason about selection on its own.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the underlying RPC call (kaia_getAccount), which is useful transparency, but 'Get' only implicitly signals a read-only operation and there is no mention of permissions, rate limits, or error behavior.

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

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

A single efficient sentence that is front-loaded with the resource and includes the RPC method without padding. Nothing superfluous, though the RPC method name is somewhat niche for the primary audience.

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 tool with two fully-documented parameters and no output schema or annotations, the description compensates by enumerating the returned fields. The remaining gap is sibling disambiguation against get_kaia_balance.

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 address and optional network parameters are already documented in the schema. The description adds no parameter-level meaning (the parenthetical lists return fields, not inputs), 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+resource (get account info) and enumerates the returned fields (type, balance, nonce, accountKey) plus the underlying RPC method kaia_getAccount. It is clear but does not distinguish itself from the closely related sibling get_kaia_balance, which an agent could easily confuse with the balance field listed here.

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

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

There is no guidance on when to use this tool versus alternatives such as get_kaia_balance or get_account_tokens. Usage is only implied by the field list, leaving the agent to infer the choice.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Get' implies a read, and it names the upstream API (KaiaScan), but there is no mention of pagination semantics across pages, rate limits, or what the inventory entries contain.

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

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

A single front-loaded sentence with no filler; the resource and scope come first. It is efficient, though it is arguably terse to the point of omitting useful framing.

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, single-required-parameter tool this is minimally adequate, and the rich schema covers inputs. With no output schema and no annotations, the description could still say something about the shape of the returned inventory list, which it does not.

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% — every parameter including address format, page, size cap, and network values is documented in the schema itself. The description adds no additional parameter meaning, 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 ('Get'), resource ('NFT inventories'), and scope ('for an address'), which cleanly separates it from get_account_tokens (fungibles) and get_nft_item (single NFT). It does not explicitly name those siblings, but the resource noun is distinctive enough to route correctly.

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

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

No guidance on when to use this versus get_nft_item, get_nft_transfers, or get_account_tokens, and no mention of prerequisites. The agent must infer the selection rule purely from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says 'Get' and names the data source ('KaiaScan API'), implying a read operation, but does not state read-only safety, authentication needs, rate limits, pagination behavior, or error handling.

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

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

A single front-loaded sentence with no filler. Every phrase ('fungible token balances', 'for an address', 'via KaiaScan API') contributes to identifying the operation and its data source.

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 tool with full schema coverage, the description states the core operation but omits useful context such as what the return value looks like (no output schema exists) and any behavioral caveats. It is minimally adequate but leaves clear gaps.

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

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

Schema description coverage is 100%, so all four parameters are already documented with types, defaults, and allowable ranges. The description adds no parameter meaning beyond what the schema provides, making the baseline of 3 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?

States a specific verb ('Get'), resource ('fungible token balances'), and scope ('for an address'), which distinguishes it from sibling tools like get_kaia_balance (native balance), get_account_nfts (non-fungible), and token-level tools such as get_token_info and get_token_transfers.

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 no explicit when-to-use guidance, no conditions that select this tool over alternatives, and no exclusions. An agent must infer that it is for fungible token balances rather than native balances or NFTs.

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 behavioral burden. It names the return fields (tx hash, from, to, value, time, status), but says nothing about ordering, pagination/rate-limit behavior, whether results are cached, or any required API key/network prerequisites for the KaiaScan API.

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

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

A single, front-loaded sentence with no filler; the verb and resource lead, and the parenthetical return-field list is compact. Slightly dense but nothing is wasted.

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

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

For a simple read tool with no output schema, naming the returned fields is helpful and largely compensates. However, with no annotations and no output schema, the absence of ordering/pagination behavior and any auth or rate-limit context leaves it only minimally complete.

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

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

Schema description coverage is 100%, so page, limit, address, and network are all already documented in the schema with defaults and max values. The description adds no additional parameter semantics beyond that, which matches the baseline 3 for high-coverage schemas.

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

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

States a specific verb+resource ('Get list of transactions for an account') and adds the data source (KaiaScan API) plus the returned fields, so it is clearly distinguishable from get_transaction (single tx) and get_token_transfers. It stops short of explicitly naming sibling alternatives, so it does not reach a 5.

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

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

The per-account scoping implies the use case (fetch an account's transaction history), but there is no explicit when-to-use guidance, no mention of when to prefer get_transaction or get_transaction_receipt instead, and no note about paginating large histories. Usage is only implied.

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

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

With no annotations at all, the description carries the burden and partially meets it by enumerating the returned fields (number, hash, parentHash, timestamp, miner, gasUsed, gasLimit, transactions). It does not state that this is a safe read-only call, what happens if the block is not found, or any network/auth constraints.

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, the lookup mechanism front-loaded and the return payload second. Every clause carries information, though the trailing field list is dense and unsorted by importance.

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

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

With no output schema, spelling out the returned fields is genuinely useful and largely compensates. The gaps are error behavior for an unknown block and per-network differences, which are minor for a straightforward single-block read.

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% (number/hex/hash format, mainnet or kairos default, includeTransactions default false), so the schema does the heavy lifting. The description adds only that includeTransactions switches between 'transactions count or list', a marginal clarification of an output-shaping flag.

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 ('Get block by number or hash') and immediately scopes the lookup key. It distinguishes itself from neighbors like get_block_number, get_block_rewards, and get_transaction by focusing on a single block object, though it never names those alternatives.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of the sibling tools that could be confused with it (get_block_number for the latest height, get_block_rewards for rewards). The only implicit signal is that it fetches one block by identifier.

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 behavioral burden. It omits freshness semantics (is 'current' latest, safe, or finalized?), caching behavior, failure modes for an unreachable network, and what shape the result takes. Only the core read intent is conveyed.

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

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

A single clean sentence with zero filler and the key concept ('current block number') front-loaded. It is efficient, though arguably under-specified rather than optimally sized.

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, single-parameter read with no output schema, the description is minimally adequate. It leaves gaps on return format and freshness that would matter for correct invocation, but the tool's low complexity keeps the miss small.

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?

Only one parameter (network) with 100% schema description coverage, so the schema already documents the accepted values and the default. The description adds no extra meaning about how network selection affects the result, 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: 'Get the current block number for the network.' An agent knows exactly what it returns. However, it does not differentiate itself from close siblings like get_block, get_chain_info, or get_block_rewards, so it loses the top mark.

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

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

No when-to-use guidance and no mention of alternatives. With siblings such as get_block and get_chain_info presumably exposing related chain state, the description never tells the agent which one to pick or under what condition.

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 behavioral burden. It notes the data originates from the KaiaScan API, but says nothing about read-only semantics, behavior for non-existent or unfinalized blocks, rate limits, or the shape of the result beyond 'rewards and burns summary'.

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

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

A single front-loaded sentence with the resource named first. The trailing parenthetical '(rewards and burns summary)' largely repeats the opening clause and could be cut, but the description is not bloated.

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 read query with full schema coverage and no output schema, the description is minimally sufficient. However, it leaves the relationship to sibling get_block and the response content ambiguous, which a slightly richer sentence could have resolved.

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% (network default and blockNumber integer semantics are documented in the schema), so the baseline is 3. The description adds no format or constraint detail beyond what the schema already states.

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: retrieves rewards and burns for a given block. It is reasonably distinguishable from the sibling get_block, which covers general block data, though the description never explicitly contrasts the two.

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 statement of when to use this versus get_block or other block-related siblings, and no conditions or exclusions. The agent can only infer usage from the name and the phrase 'for a 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?

No annotations are provided, so the description carries the full burden. It discloses the underlying data sources (getChain() and RPC getChainId()), which is minor implementation context, but says nothing about auth needs, caching, rate limits, or error behavior. As a side-effect-free read of static chain metadata the risk is low, making this borderline adequate.

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, front-loaded sentences with no filler. The trailing implementation detail ('Uses getChain() and RPC getChainId()') is of marginal value to an agent selecting the tool, but it does not bloat the description.

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

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

With no output schema, the description helpfully enumerates the returned fields (chainId, chain name, native currency), which compensates for the missing return spec. For a simple, zero-required-param read tool this is largely complete, though error/fallback behavior is unstated.

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

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

Schema coverage is 100% and the single 'network' parameter is fully documented in the schema, including its accepted values and default. The description adds nothing beyond that, 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 uses a clear verb+resource ('Get chain info for the network') and enumerates the returned fields (chainId, chain name, native currency). This is specific enough to distinguish it from data-fetching siblings like get_block_number or get_kaia_price, though it never explicitly names when it differs from them.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites, no exclusions. Usage is only inferred from the tool name and returned fields.

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, so the description carries the burden; it does disclose the upstream source (KaiaScan), the raw endpoint, and the return format ('ABI JSON as text' — a string, not a parsed object, which is genuinely useful). It omits failure behavior for unverified/nonexistent contracts, authentication needs, and rate limits.

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

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

Three short sentences, front-loaded with the purpose, then the endpoint, then the return format. The endpoint path borders on redundant with the tool name but is cheap and unambiguous.

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 read tool with no output schema, the definition covers source, return format, and precondition. The main remaining gap is error behavior for unverified contracts, which matters given the 'verified' qualifier.

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 schema already documents both parameters including the mainnet/kairos enum values and default. The path template repeats contractAddress in URL form but adds no new semantics, and the network parameter is not addressed in the description.

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

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

Specific verb+resource: gets the ABI of a contract, with the important qualifier that the contract must be verified, and names the source (KaiaScan). It doesn't explicitly distinguish itself from siblings like get_contract_source or read_contract, which an agent would have to infer.

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 statement of when to use this versus get_contract_source, read_contract, or encode_function_data. The only implicit guidance is the phrase 'verified contract', which hints at a precondition but never says what happens for an unverified address or which sibling provides source code instead.

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 burden. It usefully discloses the unverified-contract fallback (returns 'Unverified') and the underlying endpoint, but says nothing about auth, rate limits, error behavior, or how the source is returned.

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?

Very short and front-loaded: the purpose leads, followed by the endpoint and the important edge-case fallback. Every clause carries information, no padding.

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

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

There is no output schema or annotations, so the description should ideally describe the return shape (contract info vs source code fields, format). It covers the unverified case but leaves the successful response under-specified for a tool with no structured output documentation.

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 both parameters are already documented in the schema, and the description adds little beyond echoing the address path segment. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb (Get) and resource (verified contract source code) plus the data provider (KaiaScan). It is reasonably distinct from siblings like get_contract_abi or read_contract, though it never names them to sharpen the boundary.

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

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

No when-to-use guidance and no mention of the obvious alternatives (get_contract_abi, read_contract, encode_function_data). The agent must infer that this returns human-readable Solidity source rather than ABI or execution results.

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 usefully discloses the return denominations (peb, Gpeb, KAIA per unit), which no other structured field covers, but says nothing about freshness guarantees, caching, rate limits, or error 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?

Two tight sentences, front-loaded with the action and followed by the return format. Every clause earns its place with zero filler.

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

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

With no output schema, the description correctly covers return units and denominations. The only soft spot is the unexplained 'optionally KAIA per unit', since no parameter in the schema controls that option, leaving a small ambiguity about how that output is obtained.

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

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

The single 'network' parameter is fully documented in the schema (100% coverage), including its default, so the description adds no syntax or format detail beyond it. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a concrete verb and resource ('Get current gas price from the network'), which is sufficient to separate it from sibling read tools like get_kaia_price (token price) or estimate_gas (per-transaction cost estimate). It never names those siblings explicitly, so the differentiation is left implicit.

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 purpose statement; there is no explicit guidance on when to prefer this over estimate_gas or get_kaia_price, and no note on when to select mainnet versus kairos beyond the schema default. Adequate for a simple read tool but with clear gaps.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the return shape ('formatted KAIA and raw peb'), which matters since there is no output schema, but says nothing about authentication, rate limits, or behavior for non-existent addresses. Adequate but incomplete for an unannotated tool.

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

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

Two short sentences, front-loaded with purpose followed by return format, with zero filler. Every clause earns its place.

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

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

For a simple two-parameter read tool with full schema coverage, the description covers purpose and return values (compensating for the absent output schema). Only the lack of any usage routing to sibling balance/token tools keeps it from a 5.

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 (address, network with its mainnet/kairos default) are already documented in the schema. The description adds no format or constraint detail 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?

The description names a specific verb and resource ('Get KAIA balance for an address'), which is unambiguous and clearly distinct from price/transaction siblings. It does not explicitly differentiate itself from the nearest sibling, get_account_info, which could plausibly also surface a native balance, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_account_info or get_account_tokens. The agent must infer the use case purely from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It discloses useful behavioral context — the backing API path (GET /api/v1/kaia, implying a read-only fetch) and the exact returned fields — but says nothing about auth requirements, rate limits, or freshness/caching of the price data.

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

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

Two front-loaded sentences with no filler: purpose and source first, then returned fields. The API path is marginally implementation-level but still informative given there is no output 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?

With no annotations and no output schema, the description compensates well by enumerating the returned fields (usd_price, btc_price, market_cap, etc.) so the agent knows what to expect. Missing only edge details like auth or staleness, which are minor for a public price endpoint.

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 lone optional 'network' parameter is already documented in the schema. The description never mentions network, so it adds no parameter meaning beyond the schema; a 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?

States a specific verb ('Get') and resource ('KAIA price in USD') plus the data source (KaiaScan), which clearly separates it from siblings like get_gas_price (gas, not token price) and get_kaia_balance (balance, not price). It does not explicitly name sibling tools to route against, so it stops short of a 5.

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

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

There is no explicit when-to-use or when-not-to-use statement, and no alternatives are named. Usage is only implied by the tool's obvious single purpose of fetching the current KAIA token price, which matches the 'implied usage' bar rather than clear 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 the full burden. 'Get' implies a read operation and it usefully discloses the underlying endpoint (KaiaScan api/v1/nfts/:contractAddress), but it says nothing about auth requirements, rate limits, error behavior for invalid contracts, or whether the call is cached.

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, front-loaded with purpose and followed by the source API. No filler, though the endpoint reference is more operational trivia than decision-relevant 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?

With no output schema and no annotations, the description compensates well by naming the returned fields (name, symbol, total supply) and the scoping parameter. The remaining gap is behavioral context such as error cases and rate limits.

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 network and contractAddress are already documented in the schema, including the mainnet/kairos default. The description repeats 'by contract address' without adding format or constraint detail beyond what the schema provides.

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

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

Names a specific verb (Get), resource (NFT collection metadata) and the identifying key (contract address), and lists the returned fields. This implicitly separates it from item-level and account-level siblings such as get_nft_item and get_account_nfts, though it never names them outright.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of alternatives like get_nft_item or get_account_nfts, and no prerequisites. The agent must infer from the purpose phrase alone which sibling to pick.

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 does disclose the underlying data source (KaiaScan Get Nft Token Item endpoint), which is useful provenance, and 'Get' implies a read-only, non-mutating call. But it says nothing about behavior on invalid contract/token IDs, rate limits, or result caching.

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

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

Two compact sentences with the purpose front-loaded and the return fields parenthetically summarized. No filler, though the API endpoint reference is arguably incidental 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?

With no output schema, the description usefully enumerates the returned fields (owner, tokenURI, metadata), which compensates for the missing return documentation. It is largely complete for a simple read tool, with only error/edge-case behavior unaddressed.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description restates the contract/token ID lookup but adds no format or syntax detail beyond the schema, and never mentions the optional network parameter.

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

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

States a specific verb and resource ('Get a single NFT item') plus the lookup keys (contract, token ID) and the returned fields (owner, tokenURI, metadata). However, it does not differentiate itself from the sibling get_nft_info, leaving the agent to guess which NFT lookup tool is appropriate.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related sibling get_nft_info or get_nft_transfers. The agent must infer selection purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds the underlying KaiaScan endpoint, which is an implementation detail rather than agent-relevant behavior, and says nothing about pagination semantics, result ordering, rate limits, or failure modes when the contract is not an NFT.

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

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

Two tight sentences with the purpose front-loaded and no padding. The endpoint citation is arguably wasted space but it is short and comes last.

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

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

With no annotations and no output schema, the description should do more: it never characterizes the returned transfer records, ordering, or how pagination behaves across pages. Parameters are well covered by the schema, so the gap is limited to output and behavioral expectations.

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

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

Schema description coverage is 100%, so all four parameters (page, size, network, contractAddress) are already documented with defaults and constraints. The description contributes no additional syntax, format, or enum guidance 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: 'Get NFT transfer history for a collection.' This is distinguishable from fungible-token and single-item siblings on the resource axis, though it never names a sibling or scope boundary explicitly. Clear enough to select correctly.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as get_token_transfers or get_nft_item. The only routing signal is the resource name itself, which the agent must infer.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the return shape (raw allowance plus human-readable amount when decimals are known) and the decimals default, but omits permission/read-only confirmation and failure behavior for non-contract addresses.

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

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

Two tight sentences, front-loaded with the core definition followed by usage and return behavior. No filler or redundancy; every clause earns its place.

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

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

For a parameterized read tool with no output schema and no annotations, the description covers purpose, usage, and partial return semantics adequately. It could be stronger on failure modes or read-only guarantees, but nothing critical for correct invocation 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 the schema already documents all five parameters and the baseline is 3. The description adds only a light gloss by explaining that decimals drives the human-readable amount, which is marginal added meaning 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?

States a specific verb (Get) and resource (ERC-20/KIP-7 allowance) and defines the concept precisely as the amount a spender can transfer from an owner. This cleanly distinguishes it from siblings like get_token_info or get_token_holders, which cover metadata and holder lists rather than per-owner/spender allowances.

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

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

Gives a clear use case ('Use for DeFi approvals (e.g. DEX, staking)') that tells the agent when this tool is appropriate. However, it names no alternatives or exclusions, so it does not help the agent choose between this and a more general tool like read_contract.

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 behavioral burden and largely drops it. It never states the ranking/ordering of 'top' holders, that results are paginated, whether the call is read-only (implied but unstated), or any rate-limit/auth constraints. The upstream API endpoint reference adds provenance but not behavioral context.

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

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

Two short sentences, purpose front-loaded. The second sentence (KaiaScan endpoint) is marginally useful for provenance but does not help an agent decide or invoke, so it is mild filler rather than a defect.

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

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

With no output schema and no annotations, the description should at least sketch the return shape (ranked holder addresses with balances, pagination semantics). It is adequate to identify the tool but leaves an agent guessing about the result 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?

Schema description coverage is 100%, so page, size, network, and contractAddress are already documented in the schema with defaults and bounds. The description adds no parameter meaning beyond the endpoint path echoing contractAddress, 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: 'Get top holders of a fungible token.' This is clearly distinct from sibling reads like get_token_transfers, get_token_info, or get_token_allowance. It stops short of naming an alternative, but the resource noun alone disambiguates it.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives among the many token-related siblings. The agent must infer that this is the tool for holder distribution queries rather than, say, transfer history.

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 read-only nature ('Get') and names the upstream data source (KaiaScan api/v1/tokens/:contractAddress), which hints at freshness/provenance, but says nothing about rate limits, auth, or error behavior. Adequate but thin for a tool with zero annotation coverage.

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

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

Two tightly written sentences with the payload fields front-loaded. The trailing API endpoint citation is mild implementation detail that partially duplicates the stated purpose, keeping it just short of ideal.

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

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

With no output schema, the description usefully enumerates the return fields, compensating for the gap, and the read-only operation is simple enough that heavy behavioral detail isn't required. Only the absence of sibling routing keeps it from being fully complete.

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

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

Schema description coverage is 100%, so both parameters (network, contractAddress) are already documented in the schema. The description's 'by contract address' aligns with the required param but adds no format or network-selection detail beyond what the schema provides; 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 (get fungible token metadata) and even enumerates the returned fields (name, symbol, decimals, total supply), so an agent knows exactly what it yields. The word 'fungible' implicitly separates it from get_nft_info, but no sibling is named for explicit differentiation.

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

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

No when-to-use guidance, no exclusions, and no alternatives named, despite several adjacent siblings (get_account_tokens, get_token_holders, get_token_transfers) that an agent could confuse it with. Usage must be inferred entirely from the purpose statement.

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 the full burden. 'Get' implies read-only, but it omits auth requirements, rate limits, pagination behavior beyond the schema, and return format. The API endpoint reference adds minor transparency but not enough behavioral context.

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

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

Two sentences with zero waste. The core purpose is front-loaded, and the API endpoint reference is informative without being verbose.

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 schema is rich and covers parameter invocation, but with no annotations and no output schema, the description should ideally explain return values or pagination behavior. It does not, leaving a gap for an agent that needs to understand what 'recent transfers' returns.

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

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

Schema description coverage is 100%, so all four parameters are documented in the schema. The description adds no parameter-level details beyond what the schema already provides, making the baseline score of 3 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?

States a specific verb ('Get') and resource ('recent transfers of a fungible token'), and explicitly uses 'fungible' to distinguish from the sibling tool get_nft_transfers. The tool's scope is immediately clear.

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

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

No when-to-use guidance, prerequisites, or alternatives are provided. The description implies it retrieves token transfers, but it does not say when to choose this over related tools like get_account_transactions or get_token_holders.

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 the full behavioral burden. It helpfully discloses the return shape (from, to, value, blockNumber, gas, gasPrice, truncated input), which implies a read-only operation, but it says nothing about behavior when the hash is not found, network defaults, or the truncation policy beyond noting 'input truncated'.

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

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

A single sentence that front-loads the purpose and then lists the returned fields efficiently. Every clause carries information, though the parenthetical field list is dense.

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

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

For a no-annotation, no-output-schema tool the description partially compensates by naming the returned fields. However it omits error behavior, network scoping, and any note on how it differs from get_transaction_receipt, leaving notable gaps.

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

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

Schema description coverage is 100%, so both parameters (txHash format, network enum of mainnet/kairos with default) are already fully documented in the schema. The description adds only 'by hash', which duplicates the schema rather than extending it; 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 a specific verb (get) and resource (transaction by hash) and even enumerates the summary fields returned. It is clear what the tool does, but it does not explicitly distinguish itself from the sibling get_transaction_receipt, leaving an agent to infer that this is the summary-level rather than receipt-level view.

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

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

There is no guidance on when to use this versus get_transaction_receipt, get_account_transactions, or the other siblings. The 'by hash' phrasing implies the input mode but no context, prerequisites, or exclusions are stated.

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

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

With no annotations, the description carries the full burden, and it partially meets it by enumerating the receipt payload (status, blockNumber, gasUsed, contractAddress, logs count) in lieu of an output schema. It says nothing about edge cases such as pending or unknown hashes (typically null), error behavior, or rate limits.

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

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

A single compact sentence with the resource stated first and the return fields listed after; nothing is padded. The colon-separated field list is terse but readable and 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?

For a two-parameter read tool with no output schema, describing the receipt fields is genuinely useful, but the definition omits the sibling disambiguation and the pending/unknown-transaction behavior that would let an agent call it confidently in all 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?

Schema description coverage is 100%, so txHash format ('0x + 64 hex') and the network values ('mainnet or kairos', default mainnet) are already documented in the schema. The description adds no parameter-level meaning beyond that, 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 ('Get transaction receipt') and enumerates the returned fields, so an agent knows exactly what it retrieves. However, it never distinguishes itself from the sibling get_transaction, which an agent could easily confuse it with since both concern transactions.

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

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

There is no guidance on when to use this versus get_transaction or any other sibling, and no mention of prerequisites such as needing a confirmed/mined transaction. The agent must infer the distinction from the tool name alone.

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

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

With no annotations, the description carries the burden and does reasonably well: it declares the call is read-only ('no state change'), names the required inputs, and discloses the return format ('decoded result as readable text'). It omits error behavior and the effect of the network parameter, so it is not fully complete.

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

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

Three sentences, front-loaded with the operation and its read-only nature, followed by requirements, the alternative tool, and the return shape. No filler and no 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?

Covers the essentials for a five-parameter read tool with no annotations and no output schema: it discloses the read-only semantics, the required inputs, and the decoded-text return. Only minor gaps remain, such as failure modes and network-specific behavior.

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 including args and network are already documented in the schema. The description restates the three required inputs and hints at the ABI's dual string/array form, but adds no syntax or format detail beyond what the schema provides. 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 ('Read a view/pure contract function') and immediately bounds it with 'no state change', which separates it from the write/encode siblings such as encode_function_data. An agent can identify the operation without opening the schema.

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

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

Explicitly routes the agent to a prerequisite sibling: 'Use get_contract_abi first if you do not have the ABI.' That is clear context and an named alternative, but it does not state when not to use this tool (e.g. for state-changing calls).

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