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 it 'adds' a configuration, implying a write operation. It fails to disclose critical behavioral traits such as required permissions, whether the addition is permanent or reversible, potential side effects (e.g., system restart), rate limits, or error handling. This leaves significant gaps for a mutation 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 with no wasted words. It's front-loaded with the core action and purpose, making it easy to parse quickly. Every part of the sentence contributes directly to understanding the tool's function.

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 is incomplete. It lacks details on behavioral aspects (e.g., permissions, side effects), output format, error conditions, and integration with sibling tools. The high parameter coverage in the schema doesn't compensate for these omissions in a write operation 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?

The description adds no parameter-specific information beyond what the schema already provides (100% coverage). It doesn't explain relationships between parameters (e.g., how 'id' relates to 'path'), usage examples, or constraints. Baseline 3 is appropriate as the schema fully documents parameters, but the description doesn't 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 ('add') and resource ('endpoint configuration'), specifying it's for 'extensibility'. It distinguishes from siblings like 'list_endpoints' or 'get_endpoint_details' by focusing on creation rather than retrieval. However, it doesn't explicitly contrast with all possible alternatives in the sibling list.

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 'list_endpoints' or 'get_endpoint_details', nor does it mention prerequisites (e.g., admin permissions) or exclusions. The phrase 'for extensibility' hints at a use case but lacks explicit when/when-not 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 states 'read-only' which implies non-destructive behavior, but doesn't mention authentication requirements, rate limits, error conditions, or what the response looks like. For a tool with 4 parameters and no output schema, 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 at just 5 words, front-loading the essential information ('Call a read-only contract function') with zero wasted words. Every word earns its place, making it highly efficient for an agent to parse.

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 complexity (4 parameters, no annotations, no output schema), the description is insufficiently complete. It doesn't explain what 'read-only' means operationally, what format the response takes, error handling, or how this differs from similar tools. The agent lacks critical context for proper tool selection and invocation.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema. The baseline score of 3 reflects that 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 tool's purpose as 'Call a read-only contract function', specifying the verb ('Call') and resource ('contract function') with the important qualifier 'read-only'. However, it doesn't explicitly differentiate from sibling tools like 'call_endpoint' or 'call_rpc_method', 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 minimal usage guidance by indicating this is for 'read-only' contract functions, but offers no explicit when-to-use guidance, no alternatives mentioned, and no context about when to choose this over similar tools like 'call_endpoint' or 'call_rpc_method'. The agent must infer usage from the description 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 the full burden of behavioral disclosure. It states the tool calls an endpoint but lacks critical details: required permissions, HTTP methods supported, error handling, rate limits, or what the response looks like. For a mutation-capable tool (implied by body parameter), this is a significant gap in safety and operational 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, efficient sentence that directly states the tool's purpose. It's front-loaded with the core action and avoids unnecessary words, though it could be slightly more informative without sacrificing brevity.

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 complexity (4 parameters, mutation capability via body, no output schema, and no annotations), the description is inadequate. It doesn't explain return values, error conditions, or behavioral constraints, leaving the agent under-informed for a tool that can perform varied network operations.

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 minimal value beyond the schema by noting parameters are 'optional' (except endpointId), but doesn't clarify semantics like how pathParams map to URLs or when body is applicable. 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 action ('Call') and resource ('Pocket Network endpoint'), specifying it's a generic endpoint invocation tool. It distinguishes from siblings like 'add_endpoint' or 'get_endpoint_details' by focusing on execution rather than management or retrieval, though it doesn't explicitly contrast with all similar tools like 'call_contract_view' or 'call_rpc_method'.

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 mentions 'optional parameters' but doesn't specify prerequisites, appropriate contexts, or exclusions, leaving the agent to infer usage from the tool name and schema 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 the full burden of behavioral disclosure. It states the action ('Call a JSON-RPC method') but doesn't describe key traits: it doesn't specify if this is a read-only or mutating operation (though RPC methods can include writes), potential side effects, authentication requirements, rate limits, error handling, or response format. For a tool with no annotations and potential write capabilities, this lack of detail is a significant gap.

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 front-loads the core purpose without unnecessary words. It directly states 'Call a JSON-RPC method on a specific blockchain service,' which is clear and to the point. There's no redundancy or fluff, making it highly concise and well-structured for quick understanding.

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 calling RPC methods (which can involve reads or writes), the lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like safety, response format, or error cases, and it omits usage guidelines relative to many siblings. For a tool with 4 parameters and potential mutation risks, more context is needed to ensure safe and effective use by an agent.

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

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

The description adds no parameter semantics beyond what the input schema provides. The schema has 100% description coverage, with clear docs for each parameter (e.g., 'blockchain' as the name, 'method' as the RPC method name). Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate with additional context like example usage or parameter interactions.

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: 'Call a JSON-RPC method on a specific blockchain service.' It specifies the verb ('Call') and resource ('JSON-RPC method'), and distinguishes it from siblings like 'call_contract_view' or 'call_endpoint' by focusing on raw RPC calls rather than contract interactions or generic endpoints. However, it doesn't explicitly contrast with all similar tools, such as 'query_blockchain', which might also involve RPC-like queries.

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 when to prefer this over siblings like 'call_contract_view' for contract reads, 'query_blockchain' for broader queries, or other blockchain-specific tools (e.g., 'get_block_details'). There's no context on prerequisites, such as needing a valid blockchain service, or exclusions, leaving the agent to infer usage 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?

No annotations are provided, so the description carries the full burden. It mentions 'native token balance' and 'EVM chains,' but fails to disclose critical behaviors: whether it requires authentication, rate limits, error handling (e.g., unsupported chains), or the format of returned data (e.g., structured comparison vs. raw balances). This leaves significant gaps for a tool querying multiple blockchains.

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. It efficiently conveys the core purpose without unnecessary details, 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 tool's complexity (querying multiple blockchains) and lack of annotations or output schema, the description is incomplete. It adequately states what the tool does but omits behavioral details (e.g., performance, errors) and output expectations, which are crucial for effective use in this 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%, so the schema fully documents parameters. The description adds minimal value beyond the schema, only implying that 'blockchains' defaults to all EVM chains and 'network' relates to chain types, which the schema already covers with enum and default hints. No additional syntax or constraints are 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 clearly states the tool's purpose with a specific verb ('compare') and resource ('native token balance for an address across multiple EVM chains'). It distinguishes itself from sibling tools like 'get_token_balance' (single chain) or 'get_historical_balance' (temporal focus) by emphasizing cross-chain comparison.

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

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

The description implicitly suggests usage for comparing balances across EVM chains, which is distinct from single-chain balance tools. However, it lacks explicit guidance on when not to use it (e.g., for non-EVM chains or non-native tokens) or named alternatives for specific scenarios.

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. While 'convert' implies a read-only calculation, the description doesn't specify whether this requires network access, has rate limits, returns errors for invalid inputs, or provides precision details. It lacks behavioral context beyond the basic operation.

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 function with zero wasted words. It's appropriately sized for a straightforward conversion 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 simple conversion tool with no annotations and no output schema, the description is minimally complete. It identifies the operation and units but lacks details about return format, error conditions, or integration context with sibling tools. Given the tool's low complexity, it's adequate but leaves gaps in behavioral understanding.

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 clear parameter descriptions and enums, so the baseline is 3. The description adds minimal value by mentioning the three unit types, but doesn't provide additional context like conversion formulas, precision, or handling of decimal values beyond what the schema already documents.

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 as converting between wei, gwei, and eth units, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'compare_balances' or 'get_historical_balance' that might involve unit conversions indirectly, so it doesn't reach the highest 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 many sibling tools related to blockchain data retrieval and analysis, there's no indication of whether this is for standalone conversions or should be used in conjunction with other tools, nor any prerequisites or exclusions mentioned.

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

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

No annotations are provided, so the description carries full burden. It states what the tool does but lacks behavioral details: it doesn't specify if the decoding is lossless, how invalid hex is handled, whether it returns all three formats simultaneously or selectively, or any performance/rate limits. For a tool with no annotation coverage, this is a significant gap in 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 with zero waste. It's front-loaded with the core action and specifies outputs clearly, making it easy to parse. Every word contributes directly to understanding the tool's function.

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 the return format (e.g., structured object with multiple fields or a single output), error handling, or how the three decoded formats relate. For a tool with 1 parameter but significant behavioral unknowns, more context is needed to be fully actionable.

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 'hex' clearly documented in the schema. The description adds minimal value beyond the schema by implying the input is a hex string, but doesn't provide additional context like format requirements (e.g., with/without '0x' prefix, case sensitivity). Baseline score of 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 'decode' and the resource 'hex string', specifying the output formats (UTF-8, ASCII, and bytes). It distinguishes from sibling tools which are primarily blockchain-related operations, making the purpose unambiguous. However, it doesn't explicitly differentiate from potential similar encoding/decoding tools that might exist in other 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. The description doesn't mention prerequisites, error conditions, or typical use cases. Given the sibling tools are blockchain-focused, it's unclear if this is for general hex decoding or specific to blockchain data, but no explicit context is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'estimate' implies a read-only, non-destructive operation, it doesn't specify whether this requires network calls, has rate limits, returns specific error conditions, or provides gas estimates in particular units. For a tool with no 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 a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. 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 tool's moderate complexity (3 parameters, including a nested object) and lack of annotations or output schema, the description is minimally adequate. It states what the tool does but doesn't provide enough context about behavior, usage, or output format to fully guide an agent without additional inference.

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 ('blockchain', 'transaction', 'network') with descriptions and constraints. The description adds no additional meaning beyond what's in the schema, such as explaining the structure of the 'transaction' object or how 'blockchain' interacts with 'network'. 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 tool's purpose with a specific verb ('estimate') and resource ('gas required for a transaction'), making it immediately understandable. However, it doesn't explicitly distinguish itself from sibling tools like 'get_gas_price' or 'get_solana_fee_for_message', which might provide related but different functionality.

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 many sibling tools available (e.g., 'get_gas_price', 'get_solana_fee_for_message'), there's no indication of context, prerequisites, or comparisons to help an agent choose appropriately.

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 mentions retrieving 'details' and 'supported RPC methods,' but doesn't specify what details are included, whether this is a read-only operation, if there are rate limits, authentication requirements, or error conditions. For a tool with no 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality, 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 lack of annotations and output schema, the description is incomplete. It doesn't explain what 'details' include, the format of returned data (e.g., JSON structure), or how 'supported RPC methods' are presented. For a tool that likely returns structured information about blockchain services, this leaves too much ambiguity 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 ('blockchain' and 'network'). The description doesn't add any parameter-specific information beyond what's in the schema, such as examples of blockchain names beyond those listed or clarification on 'network' usage. This 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 tool's purpose: 'Get details about a specific blockchain service including supported RPC methods.' It specifies the verb ('Get details') and resource ('blockchain service'), but doesn't explicitly differentiate it from sibling tools like 'get_endpoint_details' or 'list_blockchain_services', 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. With many sibling tools available (e.g., 'get_endpoint_details', 'list_blockchain_services', 'get_supported_methods'), there's no indication of when this specific tool is appropriate, leaving the agent to guess based on the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'detailed block information' and 'optional transaction list', but fails to describe critical behaviors such as rate limits, error conditions, authentication needs, or what 'detailed' entails (e.g., fields returned). For a read operation with no annotation coverage, this is a significant gap in 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 front-loads the core purpose ('Get detailed block information') and adds a key feature ('with optional transaction list'). There is no wasted verbiage, making it highly concise and well-structured for quick understanding.

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 minimally adequate for a read tool but lacks completeness. It doesn't explain return values, error handling, or behavioral constraints, which are important for an agent to use it correctly. However, the clear purpose and full parameter schema coverage prevent a lower score.

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 4 parameters with descriptions and defaults. The description adds marginal value by implying 'optional transaction list' relates to the 'includeTransactions' parameter, but doesn't provide additional semantics beyond what the schema already states. This 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 the resource 'detailed block information', specifying it includes 'optional transaction list'. It distinguishes from siblings like 'get_block' or 'get_cosmos_block' by emphasizing details and transaction inclusion. However, it doesn't explicitly differentiate from all blockchain-specific block tools (e.g., 'get_solana_block'), 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 like 'get_cosmos_block' or 'get_solana_block', nor does it mention prerequisites or exclusions. It merely states what the tool does without contextual usage instructions, leaving the agent to infer based on parameter names like 'blockchain'.

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. The description states it's a read operation ('Get'), but doesn't mention authentication requirements, rate limits, error conditions, or what happens if the account doesn't exist. For a tool with no annotation coverage, this leaves significant behavioral gaps that could affect agent decision-making.

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 and front-loaded: a single sentence that directly states the tool's purpose and the specific information returned. Every word earns its place with no wasted text, 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 tool's moderate complexity (retrieving specific account metadata), 100% schema coverage, but no annotations and no output schema, the description is minimally adequate. It tells the agent what information will be returned (sequence, account number) but doesn't explain the format, units, or potential limitations. For a read-only tool with good schema documentation, this is acceptable but could be more 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 description adds no parameter information beyond what's already in the schema. Since schema description coverage is 100%, the baseline score is 3. The schema fully documents all three parameters (blockchain, address, network) with descriptions and enum values, so the description doesn't need to compensate, but it also doesn't add any extra context about parameter usage or relationships.

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: 'Get Cosmos account information (sequence, account number)'. It specifies the verb ('Get'), resource ('Cosmos account information'), and specific data fields returned. However, it doesn't explicitly differentiate from sibling tools like 'get_cosmos_balance' or 'get_cosmos_delegations', which also retrieve Cosmos account-related data but different information.

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 when this tool is appropriate compared to other Cosmos account tools (e.g., 'get_cosmos_balance' for balance information, 'get_cosmos_delegations' for delegation details) or general blockchain query tools. The agent must infer usage from the tool name and description 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. While 'Get' implies a read operation, the description doesn't disclose important behavioral traits like whether this requires authentication, rate limits, pagination behavior, error conditions, or what format the balances are returned in. For a tool that likely queries external blockchain data, this is a significant gap.

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 clearly states the tool's purpose with zero wasted words. It's appropriately sized for what it communicates and is front-loaded with the essential information.

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

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

Given that this is a data retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'all token balances' means in practice (native tokens only? including staked/delegated amounts?), doesn't mention response format or structure, and provides no behavioral context. For a tool that likely returns complex blockchain data, this is inadequate.

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

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

The input schema has 100% description coverage, so all parameters are documented in the schema itself. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. The baseline score 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 tool's purpose with a specific verb ('Get') and resource ('all token balances for a Cosmos SDK address'). It distinguishes itself from sibling tools like 'get_cosmos_balance' (which appears to get a single balance) by specifying 'all' balances. However, it doesn't explicitly contrast with 'compare_balances' or 'get_historical_balance', which could be related 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate compared to 'get_cosmos_balance' (for single tokens), 'compare_balances' (for comparisons), or 'get_historical_balance' (for historical data). There's also no mention of prerequisites or limitations.

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 tool's function but lacks critical details: it doesn't specify if this is a read-only operation, what permissions or authentication might be required, potential rate limits, error conditions, or the format of the returned balance. For a tool with no annotation coverage, this is a significant gap.

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 front-loads the core purpose without unnecessary words. It directly communicates the tool's function and scope, making it easy for an agent to parse quickly. Every word earns its place, with zero waste.

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 a balance query tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., numeric balance, denomination details), error handling, or behavioral constraints. This leaves the agent under-informed for proper invocation and result interpretation.

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 the input schema already documents all parameters thoroughly. The description adds no additional semantic context beyond implying that 'blockchain' and 'address' are required (as stated in the schema). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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: 'Get balance for a Cosmos SDK address on any Cosmos chain.' It specifies the verb ('Get balance'), resource ('Cosmos SDK address'), and scope ('any Cosmos chain'). However, it doesn't explicitly differentiate from sibling tools like 'get_cosmos_all_balances' or 'get_historical_balance,' 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 sibling tools like 'get_cosmos_all_balances' (which might return multiple balances) or 'get_historical_balance' (which might query past states), nor does it specify prerequisites or exclusions. This leaves 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only operation but doesn't disclose rate limits, authentication needs, error conditions, or the structure of returned data. 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 with no wasted words. It's front-loaded with the core purpose and uses precise terminology, 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 no annotations and no output schema, the description is insufficiently complete. It doesn't explain what data the block contains, how errors are handled, or any prerequisites, leaving significant gaps for a tool that fetches blockchain data.

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 three parameters. The description adds no additional meaning beyond implying height is required, which is already clear from the schema. This 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 action ('Get') and resource ('Cosmos block'), and specifies the scope ('at specific height'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'get_block_details' or 'get_cosmos_latest_block', 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 siblings like 'get_cosmos_latest_block' for the most recent block or 'get_block_details' for other blockchains, 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 states the action ('Get') but doesn't describe traits like whether it's a read-only operation, potential rate limits, authentication needs, or what the return format looks like (e.g., list of delegations with details). This leaves significant gaps for a tool that likely 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It's front-loaded and appropriately sized for its function, 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 queries, no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, data freshness, or response structure, which are crucial for an agent to use the tool effectively in this 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?

The schema description coverage is 100%, meaning all parameters are documented in the input schema. The description doesn't add any extra meaning beyond the schema, such as explaining how 'blockchain' relates to Cosmos or clarifying 'delegatorAddress' format. With high schema coverage, the baseline score of 3 is appropriate as the schema handles the parameter details.

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 ('all staking delegations for a Cosmos address'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_cosmos_account' or 'get_cosmos_all_balances', which might also retrieve related Cosmos data, so it doesn't reach the highest 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, such as other Cosmos-related tools in the sibling list. It lacks context on prerequisites, exclusions, or comparisons, leaving the agent to infer usage based on the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what 'latest block information' includes (e.g., height, timestamp, transactions), whether it's a read-only operation, potential rate limits, or error conditions. 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 unnecessary words. It's appropriately sized for a simple tool, though it could be slightly more informative without losing conciseness.

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

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

For a tool with 2 parameters, no annotations, and no output schema, the description is minimally adequate but lacks depth. It doesn't explain the return value (e.g., what 'block information' entails) or behavioral aspects like error handling. Given the complexity and lack of structured data, it should provide more context to be fully helpful.

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 clear parameter descriptions and an enum for 'network'. The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints. Given the high schema coverage, 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 the verb ('Get') and resource ('latest block information on a Cosmos chain'), making the purpose evident. However, it doesn't distinguish this tool from its sibling 'get_cosmos_block' (which presumably gets block details for a specific block), leaving room for ambiguity about when to use one versus the other.

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_cosmos_block' or other blockchain-specific block tools (e.g., 'get_solana_block'). It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage from the 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 states a 'Get' operation, implying read-only behavior, but does not clarify if it requires authentication, has rate limits, returns structured data, or handles errors. For a tool with 3 parameters and no output schema, this leaves significant gaps in understanding its 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 with no wasted words. It front-loads the core purpose ('Get chain parameters for a Cosmos module') without unnecessary elaboration, 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 complexity (3 parameters, no annotations, no output schema), the description is insufficient. It does not explain what 'chain parameters' include, how results are formatted, or potential use cases. Without annotations or output schema, more detail is needed to guide effective tool selection and invocation.

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

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

The input schema has 100% description coverage, clearly documenting each parameter (blockchain, module, network) with enums and defaults. The description adds no additional semantic context beyond what the schema provides, such as explaining module-specific parameter types or interactions. Baseline score of 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 states the tool 'Get chain parameters for a Cosmos module', which clearly indicates a read operation targeting specific blockchain parameters. However, it lacks specificity about what 'chain parameters' entail (e.g., governance settings, staking rules) and does not distinguish itself from sibling tools like 'get_cosmos_account' or 'get_cosmos_validators', which also retrieve Cosmos-related data but for different resources.

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 is provided on when to use this tool versus alternatives. The description does not mention prerequisites, such as needing a valid blockchain name or module, nor does it compare to other tools like 'query_blockchain' or 'get_cosmos_proposal' that might retrieve related data. Usage is implied through the parameter context but not 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 provided, the description carries the full burden of behavioral disclosure but offers minimal information. It implies a read-only operation ('Get'), but doesn't specify whether it requires authentication, has rate limits, returns structured data, or handles errors. This is inadequate for a tool with potential complexity in blockchain queries.

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 front-loads the core purpose without unnecessary words. It earns its place by directly stating what the tool does, making it easy to parse and understand 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 lack of annotations and output schema, the description is insufficient for a tool that interacts with blockchain governance data. It doesn't explain what 'details' are returned, error conditions, or behavioral nuances, leaving significant gaps in understanding how to use the tool 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?

The input schema has 100% description coverage, clearly documenting all three parameters. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline score of 3. However, it doesn't compensate for any gaps since there are none in the schema.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('specific governance proposal details'), making it immediately understandable. However, it doesn't explicitly differentiate from its sibling 'get_cosmos_proposals' (which likely lists multiple proposals), leaving some ambiguity about scope.

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_cosmos_proposals' or other blockchain-specific query tools. It lacks context about prerequisites, typical use cases, or any explicit exclusions, leaving the agent to infer usage 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?

No annotations are provided, so the description carries full burden. 'Get' implies a read operation, but the description doesn't disclose behavioral traits like whether this requires authentication, rate limits, pagination behavior, or what format the proposals are returned in. For a tool with no annotation coverage, this leaves significant gaps in understanding how it 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, clear sentence with zero wasted words. It's appropriately sized for a straightforward tool and front-loads the essential information. 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 the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks behavioral context, usage guidance, and output information. The high schema coverage helps, but for a tool with no annotations or output schema, more completeness would be beneficial.

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 with descriptions and enums. The description adds no additional parameter semantics beyond what's in the schema. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't need to.

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 ('governance proposals on a Cosmos chain'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_cosmos_proposal' (singular) or 'get_cosmos_proposal_votes', but the plural 'proposals' suggests a list operation rather than retrieving a specific proposal.

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 multiple Cosmos-related sibling tools (e.g., 'get_cosmos_proposal' for a single proposal, 'get_cosmos_proposal_votes' for votes), there's no indication of how this tool differs or when it's preferred. No context about prerequisites or exclusions is mentioned.

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

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

No annotations are provided, so the description carries the full burden. It states it 'Get all votes', implying a read-only operation, but doesn't disclose behavioral traits such as rate limits, authentication needs, pagination, or what 'all votes' entails (e.g., format, completeness). 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 with zero waste. It's front-loaded and appropriately sized for the tool's purpose, 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 no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., read-only nature, potential errors) and doesn't explain return values or usage context. For a tool with 3 parameters and no structured safety hints, this is insufficient.

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 (blockchain, proposalId, network). The description doesn't add any meaning beyond what the schema provides, such as explaining how proposalId relates to votes or network defaults. Baseline 3 is appropriate as the schema handles 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 verb 'Get' and resource 'all votes for a governance proposal', making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'get_cosmos_proposal' or 'get_cosmos_proposals', which are related but distinct.

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 if this should be used instead of 'get_cosmos_proposal' for vote details or how it relates to other Cosmos tools. The description lacks context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Get staking rewards' implies a read-only operation, but it doesn't specify whether this requires authentication, what format the rewards are returned in, if there are rate limits, or how historical data is handled. For a tool with 4 parameters and no annotation coverage, this leaves significant behavioral gaps for the agent.

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 gets straight to the point with zero wasted words. It's appropriately sized for a tool with a clear purpose and well-documented parameters in the schema. Every word earns its place by conveying the essential function.

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 (4 parameters, no output schema, no annotations), the description is insufficiently complete. While the purpose is clear, there's no information about return format, error conditions, authentication requirements, or behavioral constraints. For a tool that likely returns structured financial data, the description should provide more context about what 'rewards' encompasses and how results are presented.

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

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

The input schema has 100% description coverage, providing clear documentation for all 4 parameters (blockchain, delegatorAddress, validatorAddress, network). The description adds no additional parameter semantics beyond what's in the schema. According to the scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info 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?

The description 'Get staking rewards for a delegator' clearly states the action (Get) and resource (staking rewards for a delegator), making the purpose immediately understandable. It distinguishes from siblings like 'get_cosmos_balance' or 'get_cosmos_delegations' by focusing specifically on rewards rather than balances or delegation status. However, it doesn't explicitly differentiate from potential reward-related 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 no guidance on when to use this tool versus alternatives. While the name suggests it's for Cosmos-specific rewards, there's no explicit mention of when to choose this over other reward or balance tools, nor any prerequisites or constraints for usage. The agent must infer usage from the tool name and parameter names 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 full burden but only states the basic action. It doesn't disclose behavioral traits such as whether this is a read-only operation (implied by 'Get'), error handling for invalid hashes, rate limits, authentication needs, or what the return format looks like (e.g., transaction details). This leaves significant gaps for an agent.

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—'Get Cosmos transaction by hash' is front-loaded and directly conveys the core functionality without unnecessary words. 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 the tool's complexity (fetching specific blockchain transactions) and lack of annotations and output schema, the description is incomplete. It doesn't explain what data is returned, error conditions, or behavioral nuances, leaving the agent with insufficient context to use it effectively beyond basic parameter passing.

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 (blockchain, txHash, network) with descriptions and enum for network. The description adds no additional meaning beyond implying 'hash' relates to txHash, but doesn't clarify parameter interactions or provide examples. 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 tool's purpose: 'Get Cosmos transaction by hash' specifies the verb 'Get' and resource 'Cosmos transaction', with 'by hash' indicating the lookup method. It distinguishes from siblings like 'get_transaction' (generic) and 'search_cosmos_transactions' (search multiple), but doesn't explicitly mention Cosmos-specific context beyond 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. It doesn't mention when to choose it over 'get_transaction' (which might handle multiple blockchains) or 'search_cosmos_transactions' (for broader queries), nor does it specify prerequisites like needing a valid hash or blockchain 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 full burden for behavioral disclosure. 'Get specific validator details' implies a read-only operation but doesn't specify authentication requirements, rate limits, error conditions, or what 'details' includes. For a tool with no 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 at just three words, with zero wasted language. It's front-loaded with the core purpose and doesn't include unnecessary elaboration, making it efficient for quick understanding.

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 validator queries, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'details' includes, potential response formats, error handling, or how this differs from related tools. For a tool with no structured behavioral or output documentation, the description 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?

The input schema has 100% description coverage, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, making the baseline score of 3 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 'Get specific validator details' clearly states the verb ('Get') and resource ('validator details'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'get_cosmos_validators' (plural), which likely returns multiple validators rather than a specific one.

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. There's no mention of prerequisites, when-not-to-use scenarios, or comparison with similar tools like 'get_cosmos_validators' or other validator-related tools in the sibling list.

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 only states what the tool does without mentioning critical behaviors like whether it's read-only, potential rate limits, pagination, error handling, or the format of the returned list. This leaves significant gaps for an AI agent to understand how to invoke it safely and effectively.

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, direct sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose without unnecessary elaboration, which is ideal for quick understanding.

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 querying blockchain validators, the lack of annotations, and no output schema, the description is insufficient. It fails to address behavioral aspects like safety, performance, or output format, leaving the AI agent with incomplete context for proper tool selection and invocation.

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

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

The description doesn't add any parameter-specific information beyond what's in the input schema, which has 100% coverage with clear descriptions and enums. Since the schema fully documents the parameters, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract from the schema's completeness.

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 ('Get list') and resource ('validators on a Cosmos chain'), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like 'get_cosmos_validator' (singular) or other Cosmos-related tools, but the scope is reasonably clear for a list operation.

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 when to choose this over 'get_cosmos_validator' (singular) or other validator-related queries, nor does it specify prerequisites or typical use cases beyond the basic function.

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 states the retrieval action but doesn't mention whether this is a read-only operation, if authentication is required, rate limits, error conditions, or what format the documentation is returned in. 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information.

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

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

For a simple single-parameter retrieval tool with no output schema, the description provides the basic purpose but lacks important context. Without annotations or output schema, it should ideally mention the return format (e.g., HTML, markdown, JSON) and any behavioral constraints. The description is minimally adequate but has 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%, with the single parameter 'path' fully documented in the schema. The description doesn't add any parameter information beyond what's already in the schema, so it meets the baseline of 3 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 action ('Retrieve') and resource ('a documentation page from api.pocket.network/docs'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'get_endpoint_docs' or 'search_docs', which appear to be related documentation tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_endpoint_docs' or 'search_docs'. There's no mention of prerequisites, context, or exclusions, leaving the agent with no usage direction beyond the basic purpose.

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 operation without disclosing behavioral traits like error handling, rate limits, permissions, or response format. It fails to add meaningful context beyond the minimal functional statement.

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

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

The description is a single, efficient sentence with no wasted words, front-loading the core purpose and including helpful examples. It is appropriately sized for a straightforward tool, making every word count.

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 low complexity, no annotations, and no output schema, the description is minimally adequate but lacks details on behavior, errors, or output structure. It covers the basic purpose but leaves gaps that could hinder effective use by an agent.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description adds minimal value by providing examples of keys (e.g., 'avatar', 'email'), but does not elaborate on semantics beyond what the schema already specifies, 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 specific action ('Get'), resource ('ENS text records'), and target ('for a domain'), with examples that help distinguish it from siblings like 'resolve_domain' or 'reverse_resolve_domain'. It precisely communicates the tool's function without being tautological.

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 'resolve_domain' or 'reverse_resolve_domain', nor does it mention prerequisites or exclusions. It lacks context for tool selection, leaving usage decisions unclear.

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. While 'Get detailed information' implies a read operation, it doesn't specify what 'detailed information' includes, whether authentication is required, rate limits, error conditions, or response format. This is inadequate 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?

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple lookup tool and front-loads the core purpose immediately.

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

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

For a tool with no annotations, no output schema, and multiple similar-sounding siblings, the description is insufficient. It doesn't explain what 'detailed information' includes, how this differs from other endpoint-related tools, or provide any behavioral context. The agent would struggle to use this tool 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 already documents the single 'endpointId' parameter. The description adds no additional parameter context beyond what's in the schema (e.g., format examples, where to find endpoint IDs, or what constitutes a valid ID). 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 verb ('Get') and resource ('detailed information about a specific endpoint'), making the purpose immediately understandable. However, it doesn't differentiate this tool from potential siblings like 'get_endpoint_docs' or 'list_endpoints' which might provide different types of endpoint information.

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_endpoint_docs' (likely documentation-focused) and 'list_endpoints' (likely listing-focused), the agent receives no help in choosing between these similar-sounding 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves documentation, implying a read-only operation, but doesn't mention any behavioral traits such as authentication requirements, rate limits, error conditions, or the format of the returned documentation. This leaves significant gaps in understanding how the tool behaves in practice.

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, clear sentence that efficiently conveys the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly. There's no wasted verbiage, earning a high score for conciseness.

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

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

Given the lack of annotations and output schema, the description is incomplete for a tool that retrieves documentation. It doesn't explain what the documentation includes (e.g., API specs, usage examples), how it's formatted, or any dependencies. With no structured data to supplement it, the description fails to provide enough context for the agent to use the tool effectively beyond 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?

The input schema has 100% description coverage, with the single parameter 'endpointId' documented as 'The ID of the endpoint'. The description doesn't add any meaning beyond this, such as examples of endpoint IDs or where to find them. According to the rules, with high schema coverage (>80%), the baseline score is 3, as the schema adequately handles parameter semantics without extra description.

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

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

The description 'Get documentation for a specific endpoint' clearly states the verb ('Get') and resource ('documentation for a specific endpoint'), making the purpose understandable. However, it doesn't differentiate this tool from sibling tools like 'get_doc_page' or 'search_docs', which also appear to retrieve documentation-related content, leaving the scope vague regarding what makes this tool unique.

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. There are multiple sibling tools that might retrieve documentation (e.g., 'get_doc_page', 'search_docs'), but the description doesn't specify contexts, prerequisites, or exclusions for using 'get_endpoint_docs', leaving the agent to guess based on tool names 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 the full burden of behavioral disclosure. It states the tool's function but lacks details on traits like rate limits, error handling, authentication needs, or what 'current' means (e.g., real-time, cached). For a read operation without annotations, this is a significant gap in 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 with zero waste. It is front-loaded with the core purpose, making it easy to parse and understand quickly, which is ideal for conciseness.

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 (2 parameters, no output schema, no annotations), the description is minimal but covers the basic purpose. However, it lacks context on return values, error cases, or behavioral traits, making it incomplete for fully informed usage without additional 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 description coverage is 100%, with clear descriptions for both parameters (blockchain name and network type with enum). The description adds no additional meaning beyond the schema, such as examples or constraints, but the schema adequately covers the semantics, 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 action ('Get current gas price') and the resource ('for a blockchain'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'get_sui_reference_gas_price' or 'get_solana_prioritization_fees', which might serve similar purposes for specific blockchains, so it doesn't reach the highest 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 many sibling tools related to gas, fees, or blockchain queries (e.g., 'estimate_gas', 'get_sui_reference_gas_price'), there is no indication of context, prerequisites, or exclusions, leaving usage unclear.

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 tool's action but lacks details on permissions, rate limits, error handling, or response format. For a read operation with no annotation coverage, this is a significant gap in 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 is front-loaded with the core purpose. There is no wasted language, making it highly concise and well-structured for quick understanding.

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 queries and the lack of annotations and output schema, the description is incomplete. It does not cover behavioral aspects like authentication needs, rate limits, or what the return value includes, which are crucial for an agent to use the tool 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 input schema already documents all parameters. The description does not add meaning beyond the schema, such as explaining parameter interactions or constraints. Baseline 3 is appropriate when the schema handles parameter documentation effectively.

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 a specific verb ('Get') and resource ('balance'), and specifies the temporal constraint ('at a specific block height'). However, it does not distinguish this tool from sibling tools like 'get_cosmos_balance' or 'get_solana_balance', which might have similar purposes but different contexts or implementations.

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 does not mention prerequisites, exclusions, or compare it to sibling tools such as 'compare_balances' or 'get_token_balance', leaving the agent without context for 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 states the tool retrieves information (implying a read-only operation), but doesn't specify what data is returned (e.g., balance, owner, program data), error conditions, rate limits, or authentication needs. This leaves significant gaps 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 with no wasted words. It's front-loaded with the core purpose, though it could be more specific. The brevity is appropriate for a simple tool, but it risks under-specification rather than true conciseness.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'account information' includes (e.g., data fields, format), potential errors, or how results differ from sibling tools. For a tool with no structured output documentation, the description should provide more context to compensate.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('address' and 'network'). The description adds no additional semantic context beyond what's in the schema (e.g., format examples for the address or network implications). With high schema coverage, the baseline score of 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 'Get Solana account information' clearly states the verb ('Get') and resource ('Solana account information'), but it's vague about what specific information is retrieved. It doesn't differentiate from sibling tools like 'get_solana_balance' or 'get_solana_token_balance', which also retrieve account-related data but focus on specific aspects.

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 when to choose this over other Solana account tools (e.g., for general info vs. specific balances) or how it relates to non-Solana tools. Usage is implied only by the name and resource scope, with no explicit context or exclusions.

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

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

No annotations are provided, so the description carries full burden. It states what the tool does but doesn't disclose behavioral traits like whether it's a read-only operation, potential rate limits, error conditions, authentication requirements, or what the return format looks like. For a financial query tool with zero annotation coverage, this is a significant gap.

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 states exactly what the tool does with zero wasted words. It's appropriately sized for a simple query tool and front-loads the essential information immediately.

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 operation with 2 parameters and 100% schema coverage, the description is minimally adequate. However, with no annotations and no output schema, the description should ideally provide more behavioral context about what the tool returns and any operational constraints. It's complete enough to understand what the tool does but lacks depth for optimal agent usage.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema - it mentions 'Solana address' which matches the schema's description, but provides no additional context about address format, validation, or the network parameter's implications.

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 ('SOL balance for a Solana address'), making the purpose immediately understandable. It distinguishes from siblings like 'get_solana_token_balance' by specifying SOL rather than tokens, but doesn't explicitly differentiate from 'get_historical_balance' or 'compare_balances' which might also involve balances.

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 many sibling tools involving balances (e.g., 'get_solana_token_balance', 'get_historical_balance', 'compare_balances'), there's no indication of when this specific SOL balance tool is preferred or what distinguishes it from other balance-related operations.

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 mentions 'optional transactions' but fails to describe critical traits like whether this is a read-only operation, potential rate limits, authentication needs, error conditions, or what the output format looks like. For a tool with no annotations, this is a significant gap in 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 front-loads the core purpose without any wasted words. It directly states what the tool does and includes a key feature ('optional transactions'), making it appropriately sized and well-structured for quick comprehension.

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 data retrieval, no annotations, and no output schema, the description is incomplete. It doesn't explain return values, error handling, or behavioral constraints, leaving the agent under-informed. For a tool with three parameters and no structured support, more context is needed to be fully helpful.

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

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

The input schema has 100% description coverage, clearly documenting all three parameters. The description adds minimal value beyond the schema by implying the 'includeTransactions' parameter's optionality. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't provide additional syntax or format details.

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: 'Get Solana block information with optional transactions.' It specifies the verb ('Get'), resource ('Solana block information'), and scope ('with optional transactions'). However, it doesn't explicitly differentiate from siblings like 'get_solana_block_height' or 'get_block_details,' which reduces it from 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, exclusions, or comparisons to sibling tools such as 'get_solana_block_height' for height-only queries or 'get_solana_transaction' for transaction-specific details. This lack of context leaves the agent without clear 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 the full burden of behavioral disclosure. It states what the tool does but doesn't describe how it behaves—such as whether it's a read-only operation, its performance characteristics, error conditions, or what the return value looks like (e.g., numeric height, timestamp). This leaves significant gaps for an agent to understand the tool's 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, clear sentence that efficiently conveys the core functionality without any wasted words. It's appropriately sized for a simple tool and front-loads the essential information.

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

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

Given the tool's low complexity (one optional parameter) and high schema coverage, the description is minimally adequate. However, without annotations or an output schema, it lacks details on behavioral traits and return values, which could be important for an agent to use it correctly in context with many sibling tools.

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

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

The input schema has 100% description coverage, with the single parameter 'network' well-documented in the schema itself (including enum values and default). The description doesn't add any meaningful parameter semantics beyond what the schema already provides, so it meets the baseline score of 3 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's purpose with a specific verb ('Get') and resource ('latest Solana block height'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_solana_block' or 'get_cosmos_latest_block', which might retrieve similar blockchain height data for different networks.

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, compare it to sibling tools like 'get_solana_block' (which might provide full block details), or specify scenarios where this tool is preferred over others for retrieving block height.

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 tool estimates a fee, which implies a read-only, non-destructive operation, but doesn't clarify if it requires network access, has rate limits, returns specific error conditions, or provides fee details like units or currency. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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: 'Estimate fee for a serialized Solana message (base64)'. It's front-loaded with the core purpose and includes essential details without redundancy. Every word earns its place, 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?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and parameter format but lacks details on behavioral traits, usage context, and return values. Without annotations or output schema, the agent might struggle with error handling or result interpretation, though the schema provides good parameter 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 description coverage is 100%, so the input schema already documents both parameters ('message' as a base64 string and 'network' as an enum with defaults). The description adds minimal value beyond the schema by mentioning 'base64' for the message, but doesn't explain parameter interactions or provide additional context like example formats. Baseline 3 is appropriate as the schema does most of the 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: 'Estimate fee for a serialized Solana message (base64)'. It specifies the verb ('Estimate fee'), resource ('Solana message'), and format constraint ('base64'), making the function unambiguous. However, it doesn't differentiate from sibling tools like 'get_solana_prioritization_fees' or 'estimate_gas', which could also relate to fee estimation in different 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools such as 'get_solana_prioritization_fees' (which might estimate different fee types) or 'estimate_gas' (which could be for other blockchains), nor does it specify prerequisites or exclusions. Usage is implied only by the tool name and description, with no explicit 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 of behavioral disclosure. It states what the tool does but doesn't explain how it behaves—e.g., what 'recent' means (timeframe), whether it's a read-only operation, potential rate limits, error conditions, or the format of returned data. This leaves significant gaps for an agent to use it effectively.

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 front-loads the core purpose without unnecessary words. Every part of it ('Get recent prioritization fees for Solana transactions') contributes directly to understanding the tool's function, 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?

Given the complexity of blockchain fee queries, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., data freshness, error handling), output format, and how parameters affect results, which are critical for an agent to use this tool correctly in practice.

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 doesn't add any meaning beyond what's in the schema—it doesn't clarify what 'addresses' represent (e.g., transaction addresses vs. account addresses) or how 'recent' relates to the parameters. 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 action ('Get') and resource ('recent prioritization fees for Solana transactions'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_solana_fee_for_message' or 'get_solana_transaction', which could provide overlapping or related fee information.

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 prerequisites, timing considerations, or how it differs from other fee-related tools in the sibling list, leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves accounts with filters, implying a read-only operation, but doesn't cover critical aspects like rate limits, authentication needs, error conditions, pagination, or response format. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior and 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?

The description is extremely concise—a single sentence that front-loads the core purpose without unnecessary words. Every part of the sentence ('Get accounts owned by a Solana program with optional filters') contributes directly to understanding the tool's function, making it efficient and well-structured for quick comprehension.

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 complexity (interacting with Solana program accounts) and lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what the return data looks like, how filters work in practice, or any network-specific behaviors. For a tool that likely returns structured account data, more context is needed to guide 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?

The description adds minimal semantic value beyond the input schema, which has 100% coverage. It mentions 'optional filters' but doesn't elaborate on what 'RPC filters' entail or provide examples. Since the schema already documents all parameters thoroughly, the description meets the baseline by not contradicting it but doesn't enhance understanding of parameter usage or implications.

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: 'Get accounts owned by a Solana program with optional filters'. It specifies the verb ('Get'), resource ('accounts'), and scope ('owned by a Solana program'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'get_solana_account_info', which might retrieve a single account rather than program-owned accounts, leaving some ambiguity.

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 mentions 'optional filters' but doesn't specify scenarios where this is preferred over other Solana tools like 'get_solana_account_info' or 'get_solana_balance'. There's no mention of prerequisites, exclusions, or typical use cases, leaving 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 the full burden of behavioral disclosure. It states the tool retrieves transaction signatures but doesn't cover critical aspects like rate limits, authentication needs, error handling, pagination (beyond the 'limit' parameter), or return format. For a read operation with no annotation coverage, this is a significant gap in 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: 'Get transaction signatures for a Solana address (transaction history)'. It's front-loaded with the core purpose and includes clarifying context in parentheses. There's no wasted verbiage, 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?

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states the purpose but lacks behavioral details, usage guidelines, and output information. Without annotations or an output schema, the description should do more to compensate, but it meets a basic threshold for a read-only query tool.

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

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

The input schema has 100% description coverage, clearly documenting all parameters ('address', 'limit', 'network') with defaults and constraints. The description adds no additional parameter semantics beyond what the schema provides, such as address format examples or network implications. With high schema coverage, the 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 the tool's purpose: 'Get transaction signatures for a Solana address (transaction history)'. It specifies the verb ('Get'), resource ('transaction signatures'), and target ('Solana address'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_solana_transaction' or 'search_cosmos_transactions', which would require 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. It doesn't mention sibling tools (e.g., 'get_solana_transaction' for detailed transaction data or 'search_cosmos_transactions' for cross-chain queries) or specify use cases like checking transaction history versus balances. This leaves 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool's function but doesn't describe any behavioral traits such as whether it's read-only, has rate limits, requires authentication, or what the output format looks like. For a tool with zero annotation coverage, this is a significant gap, as the agent lacks crucial operational 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, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly. Every word earns its place, contributing to clarity without waste.

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 (3 parameters, no nested objects) and the absence of both annotations and an output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, usage context, and output format. While it meets a bare minimum, it doesn't fully compensate for the missing structured data, leaving gaps in completeness.

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

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

The input schema has 100% description coverage, with clear documentation for each parameter (walletAddress, mintAddress, network). The description adds minimal value beyond the schema, only implying that mintAddress is optional and affects the scope of results ('returns all token balances' if not provided). Since the schema does the heavy lifting, the 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 the tool's purpose: 'Get SPL token balance(s) for a Solana wallet.' It specifies the action ('Get'), resource ('SPL token balance(s)'), and target ('Solana wallet'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'get_solana_balance' or 'get_token_balance', which reduces the score from 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 sibling tools like 'get_solana_balance' (which might get native SOL balance) or 'get_token_balance' (which might be generic across blockchains), leaving the agent to infer usage context. This lack of explicit when-to-use or alternative recommendations results in a low 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what metadata is retrieved but doesn't cover aspects like rate limits, error handling, network latency, or whether the data is cached. For a read operation without annotations, this leaves significant gaps in understanding 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?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes specific metadata attributes 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?

Given the tool's moderate complexity (2 parameters, read-only operation), no annotations, and no output schema, the description is minimally adequate. It covers what metadata is returned but doesn't address return format, error cases, or performance characteristics, leaving room for improvement in completeness.

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 doesn't add any meaningful parameter information beyond what's in the schema, such as format examples for mintAddress or network selection implications. 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 verb 'Get' and resource 'SPL token metadata' with specific attributes (decimals, supply, authorities). It distinguishes from siblings like get_solana_balance or get_solana_account_info by focusing on token metadata, though it doesn't explicitly contrast with get_token_metadata (which appears to be a generic version).

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. It doesn't mention when to choose this over get_solana_token_balance for token data or get_token_metadata for a generic version, nor does it specify prerequisites or context for usage.

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

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

With no annotations, the description carries full burden but only states what the tool does, not how it behaves. It doesn't disclose error handling (e.g., invalid signatures), rate limits, authentication needs, or response format. For a read operation, this leaves critical behavioral traits unspecified.

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 front-loads the core purpose without unnecessary words. It's appropriately sized for a simple lookup tool, with zero waste or redundancy.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with potential complexity. It doesn't explain what transaction details are returned, error cases, or network defaults beyond the schema. For a blockchain query tool, this leaves too much unspecified for reliable 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 (signature and network). The description adds no additional meaning beyond implying signature is required, which the schema already states. Baseline 3 is appropriate as the schema handles parameter semantics adequately.

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 ('Get') and resource ('Solana transaction details by signature'), making the purpose immediately understandable. It distinguishes from siblings like get_solana_block or get_solana_account_info by specifying transaction retrieval, though it doesn't explicitly contrast with get_transaction (which might be generic).

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. It doesn't mention prerequisites, such as needing a valid signature, or compare with siblings like get_solana_signatures (for listing) or get_transaction (possibly for other blockchains). The description assumes context without explicit 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 the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns paginated results, or handles errors. This leaves significant gaps in understanding how the tool behaves in practice.

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 is 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 lack of annotations and output schema, the description is insufficient for a tool that likely returns complex balance data. It doesn't explain what 'all coin balances' entails (e.g., types of coins, formatting, or error handling), leaving the agent with incomplete context for 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 input schema already documents both parameters ('address' and 'network') with descriptions and an enum for 'network'. The description adds no additional semantic context beyond what's in the schema, such as format requirements for the address or implications of network choice, meeting the baseline for adequate 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 action ('Get') and resource ('all coin balances for a Sui address'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_sui_balance' or 'get_sui_coins', which appear to serve related but potentially different functions.

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_sui_balance' or 'compare_balances'. The description lacks context about prerequisites, such as whether the address must be valid or active, or any limitations on network availability.

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 tool's function but lacks details on permissions, rate limits, error handling, or return format. For a read operation with no annotation coverage, this is insufficient, as it doesn't inform the agent about potential constraints or outcomes beyond the basic action.

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: 'Get SUI balance for an address.' It's front-loaded with the core action and resource, with no unnecessary words or redundancy. This makes it easy for an agent to parse quickly, earning the highest score for conciseness.

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

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

Given the lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what the balance value represents (e.g., units, precision), error conditions, or how it differs from sibling tools. For a tool with no structured behavioral or output data, more context is needed to guide the agent adequately.

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

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

Schema description coverage is 100%, with clear documentation for both parameters ('address' and 'network'). The description doesn't add any semantic details beyond what the schema provides, such as address format examples or network implications. Given the high schema coverage, a baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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: 'Get SUI balance for an address.' It specifies the verb ('Get') and resource ('SUI balance'), making the action explicit. However, it doesn't differentiate from sibling tools like 'get_sui_all_balances' or 'get_cosmos_balance,' which limits its score to 4 instead of 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 sibling tools like 'get_sui_all_balances' for multiple balances or 'get_historical_balance' for time-based queries, nor does it specify prerequisites or exclusions. This lack of contextual direction results in a low 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a read operation ('Get'), but doesn't mention potential side effects, error conditions, rate limits, authentication needs, or what 'details' include. For a tool with no annotation coverage, this leaves significant gaps in understanding its 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 with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple lookup tool, 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?

For a simple read tool with no output schema and no annotations, the description is minimally adequate. It states what the tool does but lacks context about return values, error handling, or sibling differentiation. The high schema coverage helps, but overall completeness is limited given the tool's potential complexity in a blockchain 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?

The schema description coverage is 100%, with clear descriptions for both parameters (checkpointId and network). The description adds no additional parameter semantics beyond what's in the schema, such as format examples or constraints. Given the high schema coverage, a baseline score of 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 'Get checkpoint details by ID' clearly states the action (get) and resource (checkpoint details), with specificity about the identifier parameter. It distinguishes from siblings like 'get_sui_latest_checkpoint' by focusing on a specific checkpoint rather than the latest one, though it doesn't explicitly contrast 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?

The description provides no guidance on when to use this tool versus alternatives like 'get_sui_latest_checkpoint' or 'get_sui_transaction'. It lacks context about prerequisites, typical use cases, or any exclusions, leaving the agent to infer usage 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 provided, the description carries the full burden of behavioral disclosure but offers minimal information. It states the basic function but doesn't describe whether this is a read-only operation, what permissions might be needed, how pagination works with the cursor/limit parameters, rate limits, or what format the results will be in. For a tool with 5 parameters and no output schema, 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 at just 6 words, with zero wasted language. It's front-loaded with the core purpose and contains no unnecessary elaboration. While this conciseness comes at the cost of completeness, as a standalone statement it's efficiently 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?

Given the tool's complexity (5 parameters, no annotations, no output schema, and multiple similar sibling tools), the description is insufficiently complete. It doesn't help the agent understand behavioral aspects, differentiate from alternatives, or provide context about what 'coins' means in this system versus 'balances' or 'objects' in sibling tools. The agent would need to infer too much from the minimal description.

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 description provides no additional parameter information beyond what's already documented in the schema (which has 100% coverage). While the schema descriptions adequately explain each parameter's purpose, the tool description doesn't add any contextual meaning, examples, or usage patterns that would help the agent understand how to effectively use the parameters together.

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 a specific verb ('Get') and resource ('coins owned by an address'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_sui_all_balances' or 'get_sui_balance', which appear to serve related but distinct purposes in the same domain.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools like 'get_sui_all_balances' and 'get_sui_balance' that likely serve overlapping functions, the agent receives no help in selecting the appropriate tool for specific scenarios or understanding 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe return format, error conditions, rate limits, or whether this is a read-only operation. The description is minimal and lacks important 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 extremely concise - a single sentence that directly states the tool's purpose. There's zero waste or unnecessary elaboration, making it easy to parse and understand immediately.

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

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

For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what format the checkpoint sequence number returns in, whether there are any side effects, or what happens if the network is unavailable. Given the lack of structured metadata, the description should provide more complete 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?

The input schema has 100% description coverage, with the single parameter 'network' clearly documented with enum values and default behavior. The description doesn't add any parameter information beyond what's already in the schema, so the 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 the verb ('Get') and resource ('latest checkpoint sequence number'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_sui_checkpoint' which might retrieve checkpoint details rather than just the latest sequence number.

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_sui_checkpoint' or other blockchain query tools. There's no mention of prerequisites, typical use cases, or comparison with sibling 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?

No annotations are provided, so the description carries full burden. It states it 'gets' details, implying a read-only operation, but doesn't disclose behavioral traits like rate limits, error conditions, authentication needs, or what 'details' encompass (e.g., format, depth). 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 with zero waste—'Get object details by ID'—front-loaded and appropriately sized for its purpose. Every word earns its place without redundancy.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'details' include, potential return formats, or error handling. For a tool with nested parameters and multiple options, this leaves the agent under-informed about behavior and outputs.

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 parameters (objectId, options, network). The description adds no meaning beyond implying 'ID' maps to 'objectId', but doesn't clarify parameter interactions or usage. 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 'Get object details by ID' clearly states the verb ('Get') and resource ('object details'), specifying it's for Sui objects via the tool name context. It's specific about retrieving details rather than just objects, but doesn't differentiate from potential siblings like 'get_sui_owned_objects' beyond the ID focus.

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. With many sibling tools (e.g., 'get_sui_balance', 'get_sui_transaction'), the description lacks context on use cases, prerequisites, or comparisons, leaving the agent to infer based on the 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It states a read operation ('Get'), implying it's likely non-destructive, but doesn't mention any behavioral traits like rate limits, authentication needs, error conditions, or what the output looks like (e.g., paginated results). For a tool with 5 parameters and no output schema, this is a significant gap.

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, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose without unnecessary elaboration, earning the highest score for brevity and structure.

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 (5 parameters, nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain the tool's behavior, output format, or how parameters like 'query' and 'cursor' function, leaving significant gaps for an AI agent to understand and invoke it correctly in context with many sibling 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?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond implying the 'address' parameter is central, but doesn't clarify parameter interactions or usage examples. This meets the baseline for high schema coverage without adding value.

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 ('Get') and target resource ('objects owned by an address'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_sui_object' or 'get_sui_coins', which might retrieve similar Sui blockchain data, so it doesn't reach the highest score for sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for querying Sui data (e.g., get_sui_object, get_sui_coins, query_sui_events), there's no indication of specific use cases, prerequisites, or exclusions, leaving the agent to infer usage from the 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 provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't mention behavioral traits like whether it's read-only, requires authentication, has rate limits, or what the output format might be. 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 any wasted 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 the tool's complexity (a read operation with one parameter) and the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects or return values, which are crucial for an AI agent to use the tool effectively in a blockchain 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?

The input schema has 100% description coverage, with the single parameter 'network' well-documented in the schema itself. The description doesn't add any meaning beyond this, such as explaining why network selection matters for gas prices. 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 action ('Get') and resource ('reference gas price for Sui transactions'), providing specific functionality. However, it doesn't differentiate from sibling tools like 'get_gas_price' or 'estimate_gas', which might serve similar purposes in different contexts, so it doesn't reach the highest 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?

No guidance is provided on when to use this tool versus alternatives such as 'get_gas_price' or 'estimate_gas' from the sibling list. The description implies a specific use case for Sui transactions but lacks explicit context or exclusions, leaving usage unclear relative to other 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?

No annotations are provided, so the description carries the full burden. It states it 'gets' details (implying read-only), but doesn't disclose behavioral traits like rate limits, authentication needs, error conditions, or what 'details' include (e.g., format, completeness). For a read operation with no 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 a single, front-loaded sentence with zero waste: 'Get Sui transaction details by digest' efficiently conveys the core purpose. Every word earns its place, making it appropriately sized for a simple lookup tool.

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 (3 parameters, nested object) and no output schema, the description is minimally adequate but incomplete. It lacks details on return values, error handling, or usage context. With no annotations, it should provide more behavioral transparency to be fully helpful.

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 parameters (txDigest, options, network). The description adds no parameter-specific semantics beyond implying 'digest' is the key input. 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 'Get Sui transaction details by digest' clearly states the verb ('Get'), resource ('Sui transaction details'), and key input mechanism ('by digest'). It distinguishes from siblings like 'get_transaction' (generic) and 'get_sui_object' (different resource), though it doesn't explicitly contrast with 'query_sui_transactions' (search vs. lookup).

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_transaction' (generic) or 'query_sui_transactions' (search-based). The description implies it's for looking up a specific transaction by its digest, but there's no explicit when/when-not context or mention of 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 tool retrieves supported RPC methods but doesn't describe the return format (e.g., list of methods, JSON structure), potential errors, rate limits, or authentication needs. For a read operation with zero annotation coverage, this is a significant gap in 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 front-loads the core purpose without unnecessary details. It uses clear language and avoids redundancy, making it appropriately sized for the tool's complexity.

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 (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the purpose but lacks behavioral details like return format or error handling. Without annotations or output schema, more context on what to expect would improve completeness, but it's not entirely incomplete.

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 clear descriptions for both parameters: 'blockchain' as the blockchain name and 'network' with an enum and default. The description adds no additional parameter semantics beyond what the schema provides, such as examples 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 tool's purpose: 'Get all supported RPC methods for a specific blockchain service.' It specifies the verb ('Get'), resource ('supported RPC methods'), and scope ('for a specific blockchain service'). However, it doesn't explicitly differentiate from sibling tools like 'get_endpoint_details' or 'list_endpoints,' which might have overlapping functionality.

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, such as needing to know the blockchain name, or compare it to siblings like 'list_endpoints' or 'get_endpoint_details' that might list or detail endpoints. Usage is implied by the purpose but lacks explicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, it doesn't specify whether this requires API keys, has rate limits, returns formatted or raw data, or handles errors. For a tool with no 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 a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently communicates the essential function 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 read-only tool with good schema coverage but no output schema, the description adequately covers the basic purpose. However, without annotations or output schema, it doesn't address behavioral aspects like authentication needs, rate limits, or return format, leaving room for improvement in completeness.

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 minimal value beyond the schema by specifying 'ERC-20 token balance' which implies the tokenAddress should be an ERC-20 contract, but doesn't provide additional context about parameter relationships or usage examples.

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 ('Get') and resource ('ERC-20 token balance for an address'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_solana_token_balance' or 'get_cosmos_balance', which perform similar functions on different blockchains, leaving some ambiguity about scope.

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 many sibling tools for checking balances on different blockchains (e.g., get_solana_token_balance, get_cosmos_balance), there's no indication that this is specifically for ERC-20 tokens on EVM-compatible chains versus other token types or blockchain families.

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 retrieves metadata but doesn't disclose behavioral traits like error conditions (e.g., invalid addresses), rate limits, authentication needs, or whether it's a read-only operation. The description is minimal and lacks operational 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, efficient sentence that front-loads the purpose and lists key attributes without waste. It's appropriately sized for a straightforward retrieval tool.

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 for a tool with 3 parameters. It covers the basic purpose but lacks details on behavior, error handling, or return format. For a tool in a complex blockchain context, more context would be beneficial.

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 parameters (blockchain, tokenAddress, network). The description doesn't add any parameter-specific semantics beyond what's in the schema, such as format examples or constraints. 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 verb ('Get') and resource ('token metadata') with specific attributes listed (name, symbol, decimals, total supply). It distinguishes from sibling tools like 'get_token_balance' by focusing on metadata rather than balance, but doesn't explicitly contrast with 'get_solana_token_metadata' which appears to be blockchain-specific.

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. While the description implies it's for retrieving token metadata, it doesn't mention when to choose this over other metadata-related tools or what prerequisites exist (e.g., requiring a valid token address).

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 it 'gets' details, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error handling (e.g., invalid hash), response format, or whether it's idempotent. For a tool with no annotations, this leaves significant gaps in understanding its 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 with zero waste. It's front-loaded with the core purpose ('Get transaction details'), making it easy to parse quickly. Every word earns its place without redundancy.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 3 parameters. It doesn't explain what 'transaction details' includes (e.g., status, inputs/outputs), how errors are handled, or performance expectations. For a read operation in a complex domain with many siblings, more context is needed to use it 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 already documents all parameters (blockchain, txHash, network) with descriptions and enum for network. The description adds no additional meaning beyond implying 'txHash' is the key identifier, which is already clear from the schema. 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 ('transaction details'), specifying it's by transaction hash. It distinguishes from siblings like 'get_transaction_receipt' by focusing on details rather than receipt, but doesn't explicitly differentiate from other transaction-related tools like 'get_cosmos_transaction' or 'get_solana_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 alternatives. With many sibling tools for specific blockchains (e.g., 'get_cosmos_transaction', 'get_solana_transaction'), the description doesn't explain if this is a generic version or when to choose it over blockchain-specific ones. It also doesn't mention prerequisites or error conditions.

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 but only mentions what data is returned, not behavioral aspects like error handling, rate limits, permissions, or whether it's a read-only operation. It doesn't disclose if it requires specific network access or has latency considerations.

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, front-loaded with the core purpose and key return fields. Every word contributes directly to understanding the tool's function.

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 (3 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It covers what data is returned but omits behavioral context, usage scenarios, and output details, leaving gaps for an AI agent.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning beyond the schema, such as explaining parameter interactions or format examples, but doesn't contradict it either.

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 ('Get') and resource ('transaction receipt'), specifying key return fields like status, gas used, and logs. It distinguishes from siblings like 'get_transaction' by focusing on receipt details, though it doesn't explicitly mention this distinction.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'get_transaction' or 'get_block_details'. The description lacks context about prerequisites, timing (e.g., after transaction confirmation), or specific 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('List all available blockchain services/networks') but lacks details on behavior such as pagination, rate limits, authentication requirements, or what 'available' implies (e.g., active vs. all supported). 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, clear sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and efficiently conveys the core functionality, 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?

For a simple list tool with one optional parameter and no output schema, the description is minimally adequate. It covers the basic purpose but lacks behavioral details (e.g., response format, error handling) that would be helpful given the absence of annotations and output schema. The context signals indicate low complexity, so the description is somewhat complete but could be improved.

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

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

The input schema has 100% description coverage, with the single parameter 'category' documented as an optional filter. The description doesn't add any meaning beyond this, such as examples of categories or how filtering works. Given the high schema coverage, the baseline score of 3 is appropriate, as the schema already provides adequate parameter information.

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 ('List') and resource ('blockchain services/networks supported by Pocket Network'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'list_categories' or 'list_endpoints', which also list resources but different ones.

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. For example, it doesn't mention how it differs from 'list_categories' (which might list categories of services) or 'get_blockchain_service' (which retrieves details for a specific service), leaving the agent without context for selection among similar 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't mention any constraints like pagination, rate limits, or what 'available' means (e.g., filtered by permissions). For a tool with zero annotation coverage, this is insufficient.

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 fluff. It's appropriately sized and front-loaded, 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 tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks context about the return format (e.g., list structure, category details) or how it relates to siblings like 'list_endpoints'. Without output schema, the agent doesn't know what to expect from the response.

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 with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description doesn't need to add parameter semantics, and it appropriately doesn't mention any. A baseline of 4 is given since no parameters exist to explain.

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 a specific verb ('List') and resource ('endpoint categories'), making it immediately understandable. However, it doesn't differentiate itself from potential sibling tools like 'list_endpoints' or 'list_blockchain_services', which reduces its score from 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. With sibling tools like 'list_endpoints' and 'get_endpoint_details' available, there's no indication of whether this tool provides a broader categorization versus detailed listings, leaving the agent without context for 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 states the tool lists endpoints with optional filtering, but doesn't describe the return format (e.g., list structure, pagination), performance characteristics (e.g., rate limits), or any side effects. For a tool with no annotation coverage, this leaves significant gaps in understanding how it 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 that front-loads the core purpose ('List all available Pocket Network endpoints') and adds a useful modifier ('optionally filtered by category'). There is no wasted language, repetition, or unnecessary elaboration, 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?

Given the tool's low complexity (one optional parameter) and 100% schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it fails to provide behavioral context (e.g., return format, pagination) or usage guidance. For a listing tool in a server with many siblings, more completeness would be beneficial to help the agent navigate alternatives.

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 description mentions 'optionally filtered by category', which aligns with the single parameter 'category' in the input schema. Since schema description coverage is 100% (the parameter has a description), the description adds minimal value beyond what the schema provides. The baseline score of 3 is appropriate as 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 verb ('List') and resource ('all available Pocket Network endpoints'), making the purpose evident. It distinguishes itself from siblings like 'get_endpoint_details' by focusing on listing rather than retrieving details. However, it doesn't explicitly differentiate from 'list_categories' or 'list_blockchain_services', which are similar listing operations for different resources.

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 mentions optional filtering by category but doesn't specify when filtering is appropriate or compare it to other listing tools like 'list_categories' or 'list_blockchain_services'. There are no prerequisites, exclusions, or contextual advice provided.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool executes queries but doesn't describe what happens under the hood (e.g., does it parse and translate to structured calls?), potential limitations (e.g., supported blockchains, query complexity), or response format. This leaves significant gaps for an agent to understand the tool's 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 front-loads the core functionality ('Execute a natural language query to interact with blockchain data') and includes a helpful example. There's no wasted text, though it could be slightly more structured by separating the example into its own sentence for clarity.

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 interactions, no annotations, and no output schema, the description is incomplete. It doesn't address what the tool returns (e.g., structured data, raw responses), error handling, or how it differs from the many sibling tools. This makes it inadequate for an agent to use effectively without trial and error.

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

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

The input schema has 100% description coverage, with the single parameter 'query' documented as a natural language query. The description adds minimal value by reinforcing this with an example ('get the latest height for ethereum'), but doesn't provide additional semantics like supported query types or formatting rules 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?

The description clearly states the tool's purpose as executing natural language queries to interact with blockchain data, with a specific example ('get the latest height for ethereum'). It distinguishes itself from siblings by focusing on natural language interaction rather than structured API calls. However, it doesn't explicitly contrast with tools like 'search_docs' or 'get_doc_page' which might also handle queries.

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 the many sibling tools (e.g., 'get_block_details', 'get_transaction', 'search_logs'). It mentions natural language queries but doesn't specify scenarios where this is preferred over structured tools, nor does it mention any prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers no information beyond the basic action. It doesn't describe the tool's behavior, such as whether it's read-only, has rate limits, requires authentication, what the output format might be, or any side effects. This leaves critical behavioral traits completely undocumented.

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 overly concise to the point of under-specification, consisting of only two words. While brevity is valued, this lacks necessary detail and structure, failing to front-load key information or provide any explanatory context. It doesn't earn its place as a helpful description beyond the tool name.

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 complexity (5 parameters including a nested object for querying events), lack of annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, how events are structured, or any behavioral nuances, leaving significant gaps for an agent to understand and use the tool effectively in context with sibling tools.

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

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

The input schema has 100% description coverage, providing clear documentation for all parameters (query, cursor, limit, descendingOrder, network). The description adds no additional semantic context beyond what the schema already states, such as examples of query filters or network implications. However, since schema coverage is high, the baseline score of 3 is appropriate as the schema adequately handles 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 'Query Sui events' is a tautology that restates the tool name with minimal elaboration. While it indicates the tool queries events on the Sui blockchain, it lacks specificity about what 'events' refer to (e.g., smart contract events, transaction events) and doesn't distinguish it from sibling tools like 'query_sui_transactions' or 'search_logs'. This provides only a vague purpose without clear 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or comparisons to sibling tools such as 'query_sui_transactions' or 'search_logs', leaving the agent with no information to make an informed selection among similar querying 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 full burden of behavioral disclosure. It mentions 'filters' but doesn't explain what filtering capabilities exist, whether this is a read-only operation, if it requires authentication, or how results are returned (e.g., pagination details beyond the cursor parameter). The description is too brief to adequately cover behavioral traits for a query tool with complex inputs.

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 no wasted words, making it appropriately concise. However, it could be more front-loaded with critical details (e.g., specifying it's for multiple transactions) to improve structure, but it's not overly verbose or poorly organized.

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 (5 parameters including a nested object, no output schema, and no annotations), the description is incomplete. It doesn't explain what the tool returns, how to interpret results, or provide context for the filtering mechanism. For a query tool with significant input complexity, this minimal description leaves too many gaps 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 input schema fully documents all 5 parameters. The description adds no additional meaning beyond implying filtering via 'with filters', which aligns with the 'query' parameter but doesn't elaborate on syntax or options. This meets the baseline for high schema coverage without enhancing 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 'Query Sui transactions with filters' clearly indicates the action (query) and resource (Sui transactions), but it's vague about what 'filters' entail and doesn't differentiate from sibling tools like 'get_sui_transaction' or 'query_sui_events'. It states the purpose but lacks specificity about scope or distinction from 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?

The description provides no guidance on when to use this tool versus alternatives such as 'get_sui_transaction' (for single transactions) or 'query_sui_events'. There's no mention of prerequisites, context, or exclusions, leaving usage entirely implicit based on 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 provided, the description carries full burden but only states what the tool does, not behavioral traits. It doesn't disclose error conditions, rate limits, authentication needs, response format, or whether this is a read-only operation. The description is functional but lacks operational 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, efficient sentence that packs essential information: action, resource, domain types, and implementation method. Every word earns its place with zero waste 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 single-parameter tool with 100% schema coverage but no annotations and no output schema, the description adequately explains the core functionality but lacks important operational context. It doesn't describe what the tool returns (address format, error responses) or behavioral constraints, leaving gaps for an AI agent.

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

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

Schema description coverage is 100% with the single parameter 'domain' well-documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema, so it meets the baseline score of 3 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 specific action ('resolve'), target resource ('blockchain domain name'), and implementation details ('using Pocket Network endpoints'). It distinguishes from sibling tools like 'get_domain_records' and 'reverse_resolve_domain' by focusing on domain-to-address resolution.

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 domain types (ENS .eth or Unstoppable Domains) and the resolution purpose, but doesn't explicitly state when to use this versus alternatives like 'reverse_resolve_domain' or 'get_domain_records'. No explicit exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'reverse resolve' implies a lookup operation, it doesn't specify whether this requires network calls, what happens with invalid addresses, whether results are cached, or what format the response takes. For a blockchain tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 states the tool's purpose without unnecessary words. Every word earns its place, and the information is front-loaded with no redundant phrasing.

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

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

For a single-parameter lookup tool with 100% schema coverage but no annotations and no output schema, the description provides adequate basic purpose but lacks important contextual information about behavior, error handling, and response format. The description is complete enough to understand what the tool does but not how it behaves.

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 single 'address' parameter fully documented in the schema. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline of 3 for high schema coverage without adding extra value.

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 ('reverse resolve') and resource ('Ethereum address to ENS domain name'), distinguishing it from sibling tools like 'resolve_domain' which performs the opposite operation. The verb+resource combination is precise and unambiguous.