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 explains the purpose and context but doesn't mention important behavioral aspects like transaction costs (gas fees), whether approvals are revocable, security implications of unlimited approvals, or what the tool returns. For a financial transaction tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the core purpose, and the second provides important usage context. There's zero wasted language or redundancy.

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

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

For a financial transaction tool with 5 parameters, no annotations, and no output schema, the description is adequate but incomplete. It covers the 'what' and 'why' but lacks information about transaction behavior, security considerations, error conditions, or return values. Given the complexity and absence of structured metadata, more completeness would be expected.

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

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

The schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the broader context (DeFi protocol interactions) and the purpose of approvals, which helps the agent understand why these parameters matter beyond their technical definitions in the schema.

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

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

The description clearly states the specific action ('Approve another address to spend your ERC20 tokens') and the resource involved (ERC20 tokens). It distinguishes this from sibling tools like 'transfer_erc20' or 'write_contract' by focusing specifically on token spending approvals for DeFi interactions.

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

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

The description provides clear context about when to use this tool ('often required before interacting with DeFi protocols'), giving practical guidance. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, which prevents a perfect score.

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

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

No annotations are provided, so the description carries full burden. It states the tool's function but lacks behavioral details like whether it requires authentication, has rate limits, returns a boolean or detailed ownership proof, or handles errors. This is a significant gap for a tool with no 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?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to understand at a glance.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., boolean, ownership details, error formats) or behavioral aspects like performance or limitations. For a tool with 4 parameters and no structured output, more context is needed.

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%, providing detailed descriptions for all parameters. The description adds no additional parameter semantics beyond the schema, which already explains network, ownerAddress, tokenAddress, and tokenId. Baseline 3 is appropriate when 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?

The description clearly states the tool's purpose with specific verb ('Check') and resource ('if an address owns a specific NFT'), distinguishing it from siblings like get_nft_balance (which checks quantity) or get_nft_info (which retrieves metadata). It precisely communicates the verification function.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention using get_nft_balance for checking ownership of any NFT in a collection or get_nft_info for metadata retrieval. The description only states what it does, not when it's appropriate.

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

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

With no annotations provided, the description carries full burden but only states the basic function without behavioral details. It doesn't disclose if this is a read-only operation (implied but not explicit), whether it requires network access, potential rate limits, error conditions, or what the output looks like (e.g., gas units or cost in currency).

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly.

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

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

Given the complexity of gas estimation in blockchain contexts, no annotations, and no output schema, the description is insufficient. It lacks details on return values (e.g., gas limit vs. gas price), network-specific behaviors, or error handling, leaving significant gaps for an agent to operate effectively.

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 fully documents all parameters (data, network, to, value). The description adds no additional meaning beyond the schema's details, such as explaining parameter interactions or default behaviors, meeting the baseline for high coverage.

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

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

The description clearly states the verb ('estimate') and resource ('gas cost for a transaction'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from siblings like 'get_transaction' or 'write_contract' that might also involve gas considerations, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing transaction details), contrast with siblings (e.g., 'write_contract' for actual execution), or specify use cases (e.g., pre-execution planning), leaving the agent with minimal context.

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

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

With no annotations provided, the description carries the full burden. It states the tool derives an address and implies it's a read-only operation, but doesn't disclose behavioral traits like security handling (e.g., whether the private key is transmitted securely), error conditions, or performance aspects. The description adds basic context but lacks depth for a security-sensitive tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (involves cryptographic derivation) and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on output format (e.g., address format), error handling, or security implications, which are important for a tool handling private keys. With no annotations, it should provide more context.

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

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

Schema description coverage is 100%, with the parameter 'privateKey' well-documented in the schema (including format and security note). The description doesn't add any meaningful semantics beyond what the schema provides, such as examples or edge cases, so it meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('EVM address derived from a private key'), making the purpose specific and understandable. It doesn't explicitly differentiate from siblings like 'resolve_ens' or 'get_chain_info', but the focus on private key derivation is distinct enough for most contexts.

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 is provided on when to use this tool versus alternatives. For example, it doesn't mention if this is for address derivation only (vs. resolving ENS names or checking balances), or any prerequisites like needing a valid private key format. The description lacks context for tool selection.

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 must carry the full burden of behavioral disclosure. It only states the action without revealing whether the returned block includes transactions, how missing hashes are handled, or any network-specific behavior. No additional context is added.

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

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

The description is exceptionally concise at one sentence, with no wasted words. However, its brevity borders on under-specification, though it still serves a clear purpose and is not merely a tautology.

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

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

The tool lacks an output schema and annotations, and the description provides no context about return values, block structure, or how it fits among many block-related sibling tools. This is inadequate for an agent to select and invoke it confidently.

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

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

Schema coverage is 100%, with both parameters (network and blockHash) having meaningful descriptions. The tool description itself adds no parameter information, but the schema already fully documents them, warranting the baseline score.

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

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

The description 'Get a block by hash' uses a specific verb and resource, clearly distinguishing it from block-by-number or latest-block tools. However, it is minimal and does not explicitly contrast with sibling tools beyond the 'by hash' qualifier.

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 is provided on when to use this tool versus alternatives like get_block_by_number or get_latest_block. There are no exclusions, prerequisites, or alternative suggestions.

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 for behavioral disclosure. It only says 'Get a block by number' and provides no information about return format, whether transactions are included, network behavior, or any side effects. The description adds no behavioral transparency beyond the tool's name.

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

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

The description is a single sentence, but it's essentially a restatement of the tool name. It is under-specified rather than effectively concise, lacking necessary context about what a block includes or when to use this tool, so it doesn't earn 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?

The tool has no output schema and no annotations, so the description should explain return values and usage context. It fails to mention what fields the block contains, how it differs from other block-related tools, or any network constraints. The description is too minimal to be complete for an agent selecting among many similar tools.

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

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

The schema already describes both parameters with 100% coverage, including network defaults and blockNumber description. The tool description adds no extra meaning to the parameters, so it neither helps nor harms beyond the baseline provided by the schema.

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

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

The description states the verb 'Get' and the resource 'block by number', clearly indicating the core function. However, it doesn't distinguish this from sibling tools like get_block_by_hash, get_latest_block, or get_block_with_transactions, so it doesn't fully clarify what kind of block data is returned.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to use get_block_by_hash or get_latest_block. It also doesn't mention network-specific usage or any prerequisites, leaving the agent without context for tool selection.

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 of behavioral disclosure. It does not mention whether the operation is read-only, requires authentication, has rate limits, or what side effects exist. The description provides no behavioral detail beyond the bare action of 'getting'.

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

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

The description is concise, front-loaded with the verb, and contains no filler or repetition. However, it is so terse that it sacrifices informative detail, making it less effective than a slightly longer description that clarifies the output or intended use.

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

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

The tool is simple (1 parameter, no output schema) but the description still leaves significant gaps. It does not define what 'chain information' includes, what the return value looks like, or when this tool should be chosen over similar network-related tools. Given no output schema, the description should explain the returned data, but 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?

The input schema already provides full coverage of the sole parameter with examples, accepted formats (name or chain ID), and a default value. The description's phrase 'for a specific network' adds no additional semantic meaning beyond what the schema's parameter description already conveys.

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

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

The description states a clear verb and resource: 'Get chain information for a specific network'. It is specific enough to know it fetches data about a network, but it does not distinguish itself from closely related siblings like get_chain_id or get_network_metadata, and the term 'chain information' is vague about what fields are returned.

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. It does not mention exclusions, prerequisites, or how it differs from sibling tools such as get_network_metadata or get_chain_id. The description simply repeats the function's purpose without usage context.

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

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

With no annotations provided, the description carries full burden but only mentions that ERC1155 allows multiple tokens per ID. It doesn't disclose behavioral traits like rate limits, authentication needs, error conditions, or what the return value looks like (e.g., numeric balance, format). This leaves significant gaps for a tool that queries blockchain 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?

The description is perfectly concise with two sentences that directly explain the tool's purpose and a key characteristic of ERC1155 tokens. Every word earns its place with zero wasted information.

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

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

For a read-only query tool with full schema coverage but no annotations or output schema, the description is minimally adequate. It explains what the tool does but lacks important context about return format, error handling, and network behavior that would help an agent use it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline of 3 when 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?

The description clearly states the specific action ('Get the balance') and resource ('ERC1155 token ID owned by an address'), distinguishing it from sibling tools like 'get_erc20_balance' and 'get_nft_balance' by specifying the ERC1155 token standard. It also explains the unique characteristic of ERC1155 tokens allowing multiple copies of the same ID.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_nft_balance' or 'check_nft_ownership', nor does it mention prerequisites or exclusions. It simply describes what the tool does without contextual usage instructions.

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 describes what the tool does (retrieves a URI) and mentions the URI typically points to JSON metadata, but doesn't cover important aspects like whether this is a read-only operation, potential rate limits, error conditions, or authentication requirements for a blockchain query tool.

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

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

The description is efficiently structured in two sentences: the first states the core purpose, and the second provides helpful context about what the URI typically contains. Every sentence adds value with zero wasted words.

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

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

For a read-only query tool with no output schema and no annotations, the description adequately covers the basic purpose and provides helpful context about ERC1155 tokens and metadata. However, it doesn't describe the return format (what the URI looks like, whether it's resolved) or potential behavioral aspects like error handling, which would be valuable given the lack of 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?

The schema description coverage is 100%, so all parameters are well-documented in the schema itself. The description doesn't add any parameter-specific information beyond what's in the schema, but the baseline of 3 is appropriate when the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the specific action ('Get the metadata URI') and resource ('for an ERC1155 token'), with additional context about the token standard. It distinguishes from siblings like get_erc1155_balance (which gets balance) or get_nft_info (which might get different metadata).

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

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

The description implies usage by mentioning 'ERC1155 token' and 'metadata URI', suggesting it's for retrieving token metadata URIs. However, it doesn't explicitly state when to use this tool versus alternatives like get_nft_info or provide any exclusion criteria or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Get') but doesn't describe traits like whether this is a read-only operation (implied but not explicit), potential rate limits, error conditions, or what the return value looks like (e.g., balance in token units). This is inadequate for a tool with no 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?

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the complexity of blockchain operations, no annotations, and no output schema, the description is incomplete. It doesn't explain the return format (e.g., numeric balance, decimals), error handling, or behavioral traits like network support details. For a tool with 3 parameters and no structured output, more context is needed.

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 parameters (address, network, tokenAddress) with clear descriptions. The description doesn't add any additional meaning beyond what's in the schema, such as explaining parameter interactions or constraints. Baseline 3 is appropriate 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?

The description clearly states the verb ('Get') and resource ('ERC20 token balance for an address'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_native_balance' or 'get_erc1155_balance', which would require mentioning it's specifically for ERC20 tokens (though implied by the name).

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify to use 'get_native_balance' for native tokens or 'get_erc1155_balance' for ERC1155 tokens, nor does it mention prerequisites like needing a token contract address. This leaves the agent without contextual usage instructions.

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

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

With no annotations, the description carries full responsibility for disclosing behavioral traits. It does not state that the operation is read-only, what data is returned, whether it requires any special network handling, or any potential error conditions. The phrase 'Get ERC20 token information' is too vague to convey any meaningful 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?

The description is a single concise sentence with no wasted words, making it efficient. However, it is arguably too terse to be useful, bordering on under-specification rather than being a well-structured description. It earns a 4 for brevity but lacks substantive 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?

The description is incomplete for a tool with no output schema and no annotations. It does not explain what information is returned, the supported networks, or the impact of the optional 'network' parameter. The schema covers parameter formats, but the description fails to provide the necessary context about the tool's behavior and return value.

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% as both 'network' and 'tokenAddress' have descriptive text in the schema. The description adds no additional meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states that the tool retrieves ERC20 token information using a specific verb ('Get') and resource ('ERC20 token information'). However, it does not specify what exact information is returned (e.g., name, symbol, decimals, total supply) and does not distinguish it from sibling tools like get_token_supply_info or get_erc20_balance.

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

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

No guidance is provided on when to use this tool instead of alternatives. There are no mentions of prerequisites, typical use cases, or exclusions. The description simply states the action without any context about how it fits among the many other token-related tools.

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

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

With no annotations, the description must disclose behavior, but it only says 'Get the latest block.' It does not mention that it returns a block object, what fields are included, or that it supports multiple networks via the parameter. The behavior is implicitly a read operation, but no details are provided.

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

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

The description is very concise, but it is under-specified and does not earn its place since it restates the name. It lacks necessary details that would make the description valuable, so while not verbose, it is not appropriately 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?

Given there is no output schema and no annotations, the one-sentence description is inadequate. It does not explain what the latest block contains, how to interpret the response, or mention the network parameter's role, leaving an agent with significant uncertainty.

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

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

The schema description for the 'network' parameter is comprehensive (100% coverage), listing examples and default. The tool description adds nothing about parameters, but the schema already provides sufficient semantics, so the baseline of 3 applies.

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

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

The description 'Get the latest block' is a direct restatement of the tool name 'get_latest_block', adding no new information. It does not distinguish the tool from sibling block-related tools or clarify the network scope, making it a tautology.

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 vs alternatives. No mention of preferred use cases, exclusions, or how it compares to tools like get_block_by_number or get_block_by_hash. The description provides zero usage direction.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only operation ('Get') but doesn't disclose rate limits, error conditions, authentication needs, or what the output looks like (e.g., balance format, units). For a tool with zero annotation coverage, this is inadequate transparency.

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

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

The description is a single, front-loaded sentence with zero waste—every word contributes directly to the purpose. It's appropriately sized for a simple tool, avoiding unnecessary elaboration while remaining clear.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain return values (e.g., balance in wei or ether), error handling, or network support details beyond what's in the schema. For a tool in a complex blockchain context with many siblings, more guidance is needed.

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 both parameters thoroughly. The description adds no additional meaning beyond implying 'address' is for balance checking and 'network' might be optional (though schema says required: ['address'] only). Baseline 3 is appropriate as 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?

The description clearly states the verb ('Get') and resource ('native token balance for an address'), making the purpose immediately understandable. It distinguishes from siblings like get_erc20_balance and get_nft_balance by specifying 'native token' (e.g., ETH, BNB). However, it doesn't explicitly contrast with all similar tools, so it's not a perfect 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 description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like get_erc20_balance for token balances or get_chain_info for network details, nor does it specify prerequisites (e.g., needing a valid address). This leaves the agent to infer usage from context 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?

No annotations are provided, so the description carries full burden. It states the tool returns a count, not token IDs, which is useful behavioral context. However, it doesn't disclose other important traits like whether this is a read-only operation, potential rate limits, authentication needs, error conditions, or response format details beyond 'count'.

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 first sentence states the complete purpose and scope. The second sentence adds crucial clarification about what's returned. Both sentences earn their place by providing essential information not obvious from the tool name alone.

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

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

For a read operation with 100% schema coverage but no annotations or output schema, the description provides adequate purpose and return clarification. However, it lacks behavioral context about safety, performance, or error handling that would be helpful given the absence of annotations. The description is complete enough for basic usage but has gaps in operational transparency.

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 thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. According to guidelines, baseline is 3 when schema coverage is high (>80%).

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

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

The description clearly states the specific action ('Get the total number of NFTs owned') with the resource ('by an address from a specific collection'), distinguishing it from siblings like get_erc1155_balance (which handles ERC1155 tokens) and check_nft_ownership (which verifies ownership of specific tokens). It explicitly clarifies it returns count, not token IDs.

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

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

The description implies usage context by specifying 'from a specific collection' and clarifying it returns count, not token IDs, which helps differentiate from get_erc1155_balance. However, it lacks explicit guidance on when to use alternatives like check_nft_ownership for verifying specific token ownership or get_nft_info for collection metadata.

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 some return fields but doesn't mention network behavior, error conditions, authentication, or the read-only nature beyond the 'Get' verb. The 'if available' caveat is the only behavioral nuance.

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

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

A single, well-structured sentence with a clear verb, resource, and relevant return fields. No filler or redundancy. Front-loaded with the action and immediately understandable.

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 low-complexity tool with full schema coverage, the description adequately covers purpose and return fields. Without an output schema or annotations, it could benefit from mentioning network behavior or error handling, but it's sufficient for basic invocation.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no parameter semantics beyond naming the fields returned, which is baseline for full schema coverage.

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

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

The description clearly states the tool gets detailed info about a specific NFT (ERC721 token) and lists key fields (collection name, symbol, token URI, current owner). This distinguishes it from sibling tools like get_nft_collection_info (collection-level) and get_nfts_by_owner (owner-level).

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

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

The description implies usage for querying a specific NFT token, which is clear context. It doesn't explicitly name alternatives or state when not to use it, but the scope is well-defined and there are no exclusions or misleading hints.

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 full burden for behavioral disclosure. 'Get list' implies a read-only operation, but it doesn't specify what 'supported networks' means (e.g., blockchain networks, API-supported networks), whether there are rate limits, authentication requirements, or what format the list returns. This leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool with no parameters.

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 parameterless read operation with no output schema, the description is minimally adequate but incomplete. It states what the tool does but lacks context about what 'supported networks' entails, return format, or behavioral constraints. Given the simplicity (0 params, no annotations), it's functional but could be more informative.

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

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

The tool has 0 parameters, and schema description coverage is 100% (empty schema is fully described). The description doesn't need to add parameter information, so it meets the baseline expectation for parameterless tools. No additional semantic value is required or provided.

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 'Get list of supported networks' clearly states the verb ('Get') and resource ('supported networks'), making the purpose immediately understandable. However, it doesn't differentiate from siblings like 'get_chain_info' which might provide similar network-related information, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_chain_info' that might overlap, there's no indication of when this specific tool is appropriate or what distinguishes it from other network-related tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds some detail about the return fields (sender, recipient, value, data), but omits potentially important behaviors such as whether pending transactions are supported, error conditions, or the full set of fields included in 'more'. This is moderate transparency, not comprehensive.

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

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

The description is two sentences, front-loaded with the primary action and complemented by a brief list of return fields. Every sentence serves a purpose with no extraneous content, making it highly concise and well-structured.

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

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

The description is adequate for a simple lookup tool but lacks completeness: it does not enumerate all return fields beyond the initial examples, nor does it clarify multi-network support or the default network (BSC), which is only in the schema. For an agent, the vague 'and more' and absence of output schema leave uncertainty about the full response shape.

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

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

The input schema already provides full descriptions for both parameters (txHash and network), including default and example. The description adds no additional parameter semantics beyond what the schema offers, so it neither enhances nor detracts from the baseline score for high schema coverage.

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

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

The description clearly states the tool retrieves detailed information for a specific transaction by hash, including fields like sender, recipient, value, and data. This is a specific verb+resource and the purpose is unambiguous, though it does not explicitly differentiate from chain-specific transaction tools like aptos_get_transaction or sui_get_transaction.

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

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

No guidance is provided on when to use this tool versus the many chain-specific transaction lookup tools listed as siblings. The description does not mention that the network parameter allows cross-chain usage or suggest alternatives, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries full burden but reveals minimal behavioral traits. It states what the tool does but doesn't describe response format, error behavior, rate limits, authentication needs, or what a 'transaction receipt' contains. For a read operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a straightforward lookup tool. Every word earns its place.

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

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

Given no annotations and no output schema, the description is insufficiently complete. It doesn't explain what a transaction receipt contains, what format it returns in, or any behavioral aspects. For a blockchain query tool with rich potential output data, this leaves too much undefined for effective agent use.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description mentions 'by its hash' which aligns with the 'txHash' parameter but adds no additional semantic context beyond what's in the schema. No parameter-specific guidance is provided in the description, meeting the baseline for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('transaction receipt'), specifying it's retrieved 'by its hash'. It distinguishes from sibling tools like 'get_transaction' (which likely returns transaction details rather than receipt) and 'get_block_by_hash' (which operates on blocks). However, it doesn't explicitly contrast with these alternatives in the description itself.

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 is provided on when to use this tool versus alternatives. The description doesn't mention when to choose this over 'get_transaction' (which might return different data) or other blockchain query tools. There's no context about prerequisites, error conditions, or typical use cases.

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 of behavioral disclosure. It implies a read-only check by using 'Check', but does not explicitly state whether it mutates state, how it handles invalid addresses, or what network behavior to expect. For a simple check tool this is adequate, but it lacks details such as error handling or response format.

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

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

The description is a single, focused sentence that immediately conveys the core purpose. It contains no redundant information or filler, and the key terms (smart contract, EOA, address) are front-loaded. Every word earns its place.

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

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

The tool is simple with two well-documented parameters, so the description's brevity is partially justified. However, there is no mention of the return value (e.g., boolean or classification), and no coverage of edge cases like network selection defaults. Given the absence of an output schema and the existence of overlapping siblings, the description feels minimally viable but not 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?

The input schema already provides descriptions for both 'address' and 'network' (100% coverage), so the description need not repeat them. The schema itself clearly explains each parameter (address to check, network name/chain ID with default). Therefore the description adds no extra parameter semantics, placing it at the baseline of 3.

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

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

The description clearly states the tool's function: checking if an address is a smart contract or an EOA. It specifies the verb 'Check' and the resource 'address', making the purpose unambiguous. However, it does not distinguish this from the similar sibling tool 'check_address_type', so it misses the differentiator needed for 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 description provides no guidance on when to use this tool versus alternatives like 'check_address_type' or 'validate_address'. It only states what it does without any context on use cases, prerequisites, or exclusions. This leaves the agent without criteria for selecting this tool over similar checks.

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

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

Without annotations, the description carries the burden. It discloses that the function must be view/pure, implying read-only and no state change, which is useful. However, it does not mention gas costs, possible reverts, error handling, or return value structure.

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

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

The description is a single, concise sentence with no redundant words. It is front-loaded with the key action and resource.

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

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

The tool has 5 parameters and no output schema, yet the description gives no information about return values, network behavior, or error conditions. It is minimally adequate for a simple read operation but lacks the richer context an agent would benefit from.

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 parameters are documented in the schema. The description adds no additional parameter-level details, just the overall function type, which meets the baseline but does not exceed it.

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

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

The description clearly states the tool reads data from a smart contract via a view/pure function, which is specific and distinguishes it from write_contract. The verb 'read' and resource 'smart contract' are 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?

It is implied that this tool is for reading contract state, but no explicit when-to-use or exclusions are given. The sibling tool write_contract exists, but the description does not name it or any alternative, leaving usage determination to the agent.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the BSC limitation, which is useful context about network support constraints. However, it doesn't describe what happens on successful resolution (format of returned address), error conditions (invalid ENS names, network errors), rate limits, authentication needs, or whether this is a read-only operation. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is extremely concise - a single sentence with a parenthetical constraint. Every word earns its place: it states the core function and includes a critical limitation. There's no fluff or redundant information. The structure is front-loaded with the primary purpose.

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

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

Given 2 parameters with 100% schema coverage but no annotations and no output schema, the description provides the basic purpose and one important constraint (BSC limitation). However, for a resolution tool that presumably returns address data, the lack of output schema means the description should ideally mention what gets returned. The description is minimally adequate but leaves gaps about the result format and error 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 the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions ENS names and EVM addresses generally but doesn't provide additional syntax, format, or semantic details about the parameters. Baseline 3 is appropriate when the schema does all the parameter documentation work.

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

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

The description clearly states the tool's purpose: 'Resolve an ENS name to an EVM address' - a specific verb (resolve) and resource (ENS name). It distinguishes from siblings by mentioning EVM address resolution, which no other tool explicitly does. However, it doesn't fully differentiate from potential similar resolution tools that might exist, keeping it at 4 rather than 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 description provides some usage context with the parenthetical '(not supported on BSC)', which implies when NOT to use it. However, it doesn't explicitly state when TO use it versus alternatives, nor does it mention any of the sibling tools as alternatives for related tasks. The 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?

With no annotations provided, the description carries full burden but lacks critical behavioral details. It doesn't mention that this is a blockchain transaction (implying irreversible changes, gas fees, network confirmation), security risks of private key exposure, or that it modifies on-chain state. The ERC1155 explanation is informative but doesn't cover tool 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 sentences with zero waste—first states the tool's purpose, second explains ERC1155. Well-structured and front-loaded, though the ERC1155 explanation might be more appropriate as context rather than core 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?

For a complex blockchain transaction tool with 6 parameters, no annotations, and no output schema, the description is inadequate. It misses critical context: irreversible nature, gas costs, network dependencies, error handling, and what the tool returns (e.g., transaction hash). The ERC1155 explanation doesn't compensate for these 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 parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond the ERC1155 standard explanation, which doesn't directly clarify individual parameters. Baseline 3 is appropriate 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?

The description clearly states the action ('Transfer') and resource ('ERC1155 tokens to another address'), and distinguishes ERC1155 from other token standards. However, it doesn't explicitly differentiate from sibling tools like transfer_erc20 or transfer_nft, which handle different token types.

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

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

No guidance on when to use this tool versus alternatives like transfer_erc20 or transfer_nft. The description mentions ERC1155's multi-token capability but doesn't specify use cases (e.g., batch transfers, semi-fungible tokens) or prerequisites like needing the private key for signing.

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 states the action ('transfer') but lacks details on critical behaviors: it doesn't mention that this is a write operation requiring gas fees, potential for transaction failure, confirmation times, or that it modifies blockchain state. The description is minimal and misses key operational context needed for safe use.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to scan. Every word earns its place, and there's no redundant or verbose phrasing.

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

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

Given the complexity (a blockchain write operation with 5 parameters, no annotations, and no output schema), the description is incomplete. It doesn't address behavioral risks (e.g., irreversible transfers, gas costs), success/failure outcomes, or integration with sibling tools like 'estimate_gas'. For a tool with significant implications, more context is needed to guide safe and effective use.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters with clear descriptions. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain parameter interactions or provide examples). Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate or enhance understanding.

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

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

The description clearly states the action ('transfer') and resource ('ERC20 tokens'), specifying the target ('to an address'). It distinguishes from siblings like 'transfer_native_token' and 'transfer_nft' by specifying ERC20 tokens, but doesn't explicitly differentiate from 'transfer_erc1155' beyond the token type. The purpose is specific but could be more precise about sibling 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 explicit guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites (e.g., needing token approval via 'approve_token_spending'), network selection considerations, or when to choose this over other transfer tools like 'transfer_native_token'. Usage is implied from the name and parameters but not articulated.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states what the tool does but doesn't disclose critical traits: whether it's a read-only or write operation (implied write from 'transfer'), authentication requirements beyond the private key parameter, rate limits, error conditions, or what happens on failure. The description lacks transparency about the tool's operational 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?

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a straightforward tool and front-loads the essential information without unnecessary elaboration.

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

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

For a tool that performs financial transactions (implied by 'transfer') with no annotations and no output schema, the description is insufficient. It doesn't cover authentication needs, security implications, error handling, or return values. Given the complexity and potential risks of token transfers, the description should provide more context about behavior and outcomes.

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 fully documents all four parameters. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain parameter interactions, constraints, or provide examples of valid combinations. The baseline score of 3 reflects adequate coverage through the schema alone.

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

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

The description clearly states the action ('transfer') and resource ('native tokens') with examples of specific tokens (BNB, ETH, MATIC). It distinguishes from sibling tools like transfer_erc20 and transfer_erc1155 by specifying 'native tokens' rather than token standards. However, it doesn't explicitly mention the blockchain context that would further differentiate it from generic 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 provides no guidance on when to use this tool versus alternatives like transfer_erc20 or transfer_nft. It doesn't mention prerequisites (e.g., needing a private key, sufficient balance), nor does it clarify network-specific considerations. The agent must infer usage from the tool name and parameters 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 provided, the description carries the full burden of behavioral disclosure. It successfully communicates critical behavioral traits: that this is a write/mutation operation (implied by 'Transfer'), requires private key authentication, involves transaction signing, and has security implications. It doesn't mention gas costs, confirmation times, or error conditions, but covers the essential safety profile.

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

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

The description is perfectly concise with two sentences that each earn their place: the first states the core purpose, and the second provides critical behavioral context about authentication requirements. No wasted words or redundant information.

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

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

For a mutation tool with no annotations and no output schema, the description does well by covering the essential safety profile (private key requirement, transaction signing). However, it doesn't mention what happens on success/failure, return values, or gas considerations, which would be helpful given the complexity of blockchain transactions.

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

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

Schema description coverage is 100%, so the schema already fully documents all 5 parameters. The description adds minimal value beyond the schema, only implying that privateKey belongs to the 'current owner' and that tokens are ERC721. Baseline 3 is appropriate 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?

The description clearly states the specific action ('Transfer an NFT') and resource ('ERC721 token'), including the direction ('from one address to another'). It distinguishes from siblings like transfer_erc20, transfer_erc1155, and transfer_native_token by specifying NFT/ERC721 tokens.

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

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

The description provides clear context about when to use this tool (NFT transfers) and implicitly distinguishes it from other transfer tools by specifying ERC721 tokens. However, it doesn't explicitly state when NOT to use it or name specific alternatives like transfer_erc20 for fungible tokens.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'state-changing function' which implies mutation, but doesn't cover critical aspects: transaction costs (gas), network confirmation times, irreversible nature of blockchain writes, authentication requirements (private key usage), or error handling. For a high-stakes write operation, this is insufficient transparency.

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

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

The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately front-loaded with the essential action and target. Every word earns its place in this compact formulation.

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 complex blockchain write operation with 6 parameters, no annotations, and no output schema, the description is inadequate. It doesn't address transaction lifecycle, error scenarios, cost implications, or return values. Given the high-stakes nature of smart contract interactions and the rich sibling tool ecosystem, more contextual information is needed for safe and effective use.

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

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

Schema description coverage is 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how ABI matches functionName), format requirements, or practical examples. With full schema coverage, the baseline of 3 is appropriate as the description doesn't enhance parameter understanding.

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

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

The description clearly states the action ('write data') and target ('smart contract') with the specific mechanism ('calling a state-changing function'), which distinguishes it from read-only operations like 'read_contract'. However, it doesn't explicitly differentiate from other state-changing tools like 'transfer_erc20' or 'approve_token_spending', which are more specific implementations of contract writes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a private key for signing), contrast with 'read_contract' for non-state-changing calls, or explain when to use more specialized tools like 'transfer_erc20' instead. This leaves the agent without contextual decision-making help.

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