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

With no annotations, the description must carry behavioral disclosure. It does reveal that the call is pay-per-call and that it returns both native balance and live USD value, which is useful. However, it does not mention failure modes, network assumptions, or what happens for invalid addresses, so transparency is only partial.

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

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

The description is two short sentences with no filler. The core function is front-loaded, and the pricing detail is relevant and succinctly included.

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

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

For a simple two-parameter balance tool, the description names the expected outputs adequately. But there is no output schema, no explanation of the optional fields parameter, and no error or edge-case context, so an agent is left to guess how to customize or interpret results.

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 address parameter is documented in the schema, but the optional 'fields' parameter has no schema description and is not explained in the tool description. Since schema description coverage is only 50%, the description needed to compensate by explaining the fields parameter, and it does not.

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 immediately identifies the resource (base address) and the output (native balance and live USD value). It clearly distinguishes this from sibling tools by focusing on balance retrieval for a single address, and the 'base' prefix sets the chain 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 gives no explicit guidance on when to use this tool versus alternatives such as polygon_balance or base_health. It mentions pay-per-call pricing, which is a cost signal, but does not state conditions, exclusions, or situations where a sibling tool would be more appropriate.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does add useful context by disclosing pay-per-call cost ($0.005 USDC) and support for the 'latest' keyword. It does not mention auth, rate limits, or error behavior, though the read-only nature of a block lookup is reasonably implied.

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

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

Two sentences with no wasted words: the purpose, supported lookup value, returned fields, and pricing are all front-loaded. Every clause adds useful 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 two-parameter lookup, the description covers purpose, return fields, and cost. It is incomplete on the 'fields' parameter semantics and provides no error or fallback behavior, and there is no output schema to compensate for those 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?

The schema documents 'number' clearly, and the description reinforces it by saying 'block number or latest'. However, the 'fields' parameter is a bare string with no schema description, and the description only lists possible output fields without explaining how to use the parameter, its accepted format, or its default behavior.

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 names the resource (a Base block) and enumerates the returned data: hash, timestamp, tx count, gas used, and base fee. It also specifies the accepted lookup form, block number or 'latest'. It does not use an explicit verb like 'get' or 'fetch', and it does not explicitly distinguish itself from sibling polygon_block, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus alternatives. An agent must infer from the base_* prefix and sibling set that this is the Base-chain block lookup. No prerequisites, exclusions, or alternative tools 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, the description carries the full burden of behavioral disclosure. It does disclose the pay-per-call cost ($0.01 USDC) and outlines the three output dimensions: contract status, bytecode size, and ERC-20 metadata. However, it does not explain behavior for non-contract addresses, invalid addresses, or what metadata fields are returned, leaving some behavioral uncertainty.

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 before the pricing note. Every word contributes meaningful information, with no redundancy or padding.

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

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

For a simple one-parameter tool with no output schemahare, the description adequately covers the main purpose, output categories, and cost. It could be more complete by specifying exact return formatting or behavior for non-contract addresses, but it is not critically incomplete for an agent to select and call the 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 schema has 100% coverage for the single parameter, 'address', and the description adds little beyond restating 'base address'. The baseline of 3 applies because the schema already documents the parameter fully; the description does not need to compensate.

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 identifies the tool's purpose: checking whether a base address is a contract, reporting bytecode size, and returning ERC-20 metadata when applicable. It is specific enough to be distinguished from sibling tools like base_balance or base_tx, though it lacks an explicit action verb like 'check' or 'inspect'.

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

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

There is no guidance on when to prefer this tool over alternatives, such as base_token or base_balance. The phrase 'if applicable' hints at conditional use cases, but the description does not state prerequisites, exclusions, or alternative tools, so the agent must infer when this is the right choice.

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

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

There are no annotations, so the description carries the burden. It does disclose a meaningful behavioral fact beyond the schema: the call is paid per request ($0.005 USDC). However, it does not mention authentication, rate limits, response behavior, or side effects, so coverage is partial.

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

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

The description is compact and front-loaded with the core result, and the per-call pricing note is useful and non-redundant. A minor point is lost because the chain name could be made more explicit for an agent selecting among chain-specific siblings.

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 output schema, one undocumented optional parameter, and no annotations, the description is too thin. It tells the agent what data is returned and the cost, but not the meaning of the fields parameter, network identification, or relationship to sibling gas tools.

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

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

The schema has one parameter, fields, with no schema description, and the description does not explain what fields accepts or how it affects the response. With 0% schema description coverage, the description needed to compensate but does not.

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

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

The description states a specific output: current base gas price in gwei and wei, plus estimated cost of a 21k native transfer. This distinguishes it from sibling tools like base_health or base_balance, though it does not explicitly differentiate it from polygon_gas.

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 about when to use this tool versus alternatives. The description implies a gas-price use case but does not explain when to choose base_gas over polygon_gas or other network-specific tools, leaving selection to inference.

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

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

With no annotations, the description carries the full burden and does add value by disclosing the pay-per-call cost ($0.002 USDC), which is a meaningful operational trait. However, it does not disclose failure behavior, data freshness, or how the optional fields parameter affects output, so transparency is partial.

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

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

Two sentences with zero waste: the core purpose and returned fields are front-loaded, and the cost disclosure follows. 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?

Adequate for a simple one-optional-parameter read-only tool: the description covers what data is returned and the cost, with no output schema or annotations present. Gaps include exact field name syntax for the 'fields' parameter (only implied) and output format, but these are minor for a health-check 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?

Schema coverage is 100%, setting a baseline of 3, but the description adds value by enumerating the data fields (chain id, latest block, gas price, token USD price), which effectively documents the valid values for the optional 'fields' parameter beyond the schema's generic 'comma-separated subset of fields' wording.

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

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

The description states a specific resource ('base network health') and enumerates exactly what it returns: chain id, latest block, gas price, and native token USD price. This clearly differentiates it from siblings like base_block, base_gas, and base_balance, which each cover a narrower slice of data.

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

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

No when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives or explain when an agent should choose this consolidated health snapshot over siblings like base_gas (gas price) or base_block (block data). Usage must be entirely inferred from the tool name and field 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?

No annotations are provided, so the description carries the transparency burden. It usefully discloses the pay-per-call cost and the fact that three stablecoins are fetched in one call. However, it omits output format, zero-balance handling, and error behavior, which are relevant for a call that charges per request.

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

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

The description is two concise sentences with no filler. The core purpose and the cost caveat are front-loaded, making it easy for an agent to quickly parse the essential details.

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 one-parameter read tool, the description is close to sufficient: it names the address input, the assets returned, and the cost. Yet with no output schema and no annotations, it leaves the expected response shape and edge-case behavior unspecified, so it is not fully complete.

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

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

Schema coverage is 100%, and the only parameter, address, already has a clear description. The tool description adds asset context but does not meaningfully expand on the address format, validation, or chain details beyond what the schema already provides.

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

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

The description clearly states that the tool returns USDC/USDT/DAI balances for a base address and emphasizes that this is done in a single call. This gives it a specific resource and scope, though it does not explicitly name sibling alternatives like base_balance for 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?

There is no guidance on when to prefer this tool over siblings such as base_balance, base_token, or polygon_stables. The cost and stablecoin scope imply a use case, but no exclusions, alternatives, or decision rules are 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, the description carries the burden of behavioral disclosure. It does reveal the pay-per-call cost ($0.02 USDC) and the 'live' nature of data, which are useful behavioral traits. However, it does not disclose error handling, response format, or any potential side effects (though it is a read operation). The cost disclosure is a positive addition, but other aspects like rate limits or failure behavior are missing.

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

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

The description is two concise sentences. The first sentence front-loads the core data fields, and the second covers the cost. There is no fluff or repetition. Every sentence adds value, 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 single-parameter tool with no output schema, the description is fairly complete. It lists the returned data (price, liquidity, volume, pairs, metadata), specifies the token type (base ERC-20), and notes the cost. It could mention error cases (e.g., invalid address) or confirm that it's a read-only operation, but these are minor gaps given the simplicity of the tool. The description covers most essential 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%, as the schema itself describes the parameter as 'base ERC-20 token address'. The tool description adds no new semantic information about the parameter beyond that; it repeats the scope ('any base ERC-20 token') but doesn't clarify format, checks, or edge cases. Baseline of 3 is appropriate since the schema already documents the parameter 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 tool's function: it provides live price, liquidity, 24h volume, DEX pairs, and onchain metadata (name/symbol/decimals) for a base ERC-20 token. The specific resource (token) and the scope ('any base ERC-20 token') distinguish it from sibling tools like base_balance or base_trending, which cover different data types.

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

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

The description implies usage by focusing on token-specific data, but it does not explicitly state when to use this tool over siblings, nor does it mention exclusions or alternatives. For instance, it doesn't say 'use base_balance for wallet balances' or 'use base_trending for trending tokens'. The purpose is clear enough that an agent could infer usage, but explicit guidance is absent.

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 present, the description must carry behavioral disclosure. It usefully adds pay-per-call cost ($0.02 USDC), the 24h volume window, and the DexScreener boost source. However, it does not disclose output format, ordering, limits, or any side effects, leaving the behavior only partially described.

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

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

The description is very short and front-loads the core purpose. The cost disclosure is relevant and concise. The phrase 'Fresh feed for agents' adds some fluff but is not harmful, so the description remains efficient overall.

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 output schema and one undocumented optional parameter, the description should provide more operational context. It conveys the general purpose and cost but omits what response fields to expect, how the single parameter affects results, and any behavior around freshness or pagination. This is a meaningful gap for correct invocation and 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?

There is one parameter, 'fields', with 0% schema description coverage. The description never mentions the parameter or how to use it, so an agent has no hint of valid values or behavior. The description does nothing to compensate for the schema's lack of 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 states a specific resource ('base DEX pairs'), a metric ('24h volume'), and a data source ('DexScreener boosts'). It is clearly distinct from sibling tools like base_health, base_block, and base_tx, and mirrors the pattern of polygon_trending. The term 'trending' is somewhat nominal rather than a strong verb, but the intent is unambiguous.

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

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

There is no guidance on when to use this tool instead of alternatives such as base_tx or base_stables. 'Fresh feed for agents' vaguely implies timely/snapshot data, but it does not explain selection criteria or compare against sibling tools. An agent would have to 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, the description carries the behavioral burden. It discloses the read-style output contents and the pay-per-call cost, but does not mention errors, rate limits, or whether any side effects occur. For a simple lookup this is adequate but not rich.

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

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

The description is compact, front-loaded, and every phrase earns its place. The cost note is useful operational context, not filler.

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

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

For a single-parameter, read-only style lookup, the description succinctly covers input, output contents, and cost. It lacks explicit alternative routing and caveats, but the tool's low complexity makes it essentially 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 single parameter hash is already well documented in the schema ('Transaction hash (0x...)'). The description adds minimal incremental meaning by specifying 'base', so the high schema coverage warrants the baseline score of 3.

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

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

The description clearly identifies the resource (a Base transaction hash) and the output contents (status, block, gas, transfer summary). It distinguishes from siblings by chain and resource type, though it lacks an explicit verb.

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

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

The phrase 'for a base transaction hash' implies when to use it, and sibling names like polygon_tx add context. However, it does not explicitly name alternatives or state when not to use this tool.

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. It discloses the pay-per-call cost and that a live USD conversion is involved, which is beyond trivial knowledge. It does not mention error behavior, network assumptions, or rate limits, but for a simple read query the disclosure is reasonable.

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

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

A single, dense sentence conveys the core function and the cost. It is front-loaded with the purpose, and every word earns its place with no filler.

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

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

The description covers the basic purpose and cost, and the return content is implied (balance + USD value). However, the unexplained 'fields' parameter and lack of any output schema details leave an agent guessing about optional behavior, making it minimally adequate rather than complete.

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

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

Schema coverage is only 50% and the description adds no meaning for the 'fields' parameter at all. The only parameter mentioned implicitly is 'address', which the schema already describes. The description fails to compensate for the missing 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 resource ('native balance and live USD value') and scope ('any polygon address'). It is unambiguous enough to differentiate from polygon health, block, token, etc., though it does not name a specific sibling alternative as a contrast.

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 pay-per-call cost is noted, which is useful for deciding whether to call. However, there is no explicit when-to-use guidance or comparison with alternatives like base_balance or polygon_stables; usage is inferred primarily from the tool name.

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

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

With no annotations provided, the description bears the behavioral burden; it does disclose a notable behavior by stating 'Pay-per-call ($0.005 USDC)' and it lists the fields that will be returned. However, it does not state read-only semantics, default behavior when no block number is supplied, response structure, or error/rate-limit behavior, leaving relevant 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 entire definition is one tight, front-loaded sentence. It starts with the core purpose, specifies the key selection mechanism, enumerates the returned data, and appends the pricing detail without wasted words.

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

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

For a tool with no output schema and no annotations, the description should be self-sufficient, but it omits crucial invocation details: the meaning of 'fields', whether 'number' has a default when omitted (required list is empty), and what the full response shape is. The listed output fields help, but an agent could still call the tool incorrectly.

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

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

Schema coverage is only 50%, and the description adds little beyond what the schema already says. It repeats that a block can be addressed by number or 'latest', which the schema documents, but it never explains the 'fields' parameter, its accepted format, or how the listed output fields relate to it.

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

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

The description clearly identifies the resource (a Polygon block), the lookup key (number or 'latest'), and the returned contents (hash, timestamp, tx count, gas used, base fee), which distinguishes it from chain-specific siblings like base_block. It lacks an explicit verb such as 'fetch' or 'get', so it falls just short of the strongest purpose statement.

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

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

The description gives no guidance about when to choose this tool over alternatives, nor does it mention any exclusions or fallback tools. It is inferable from the name and the phrase 'polygon block' that this is for block header data, but the decision context is left unstated.

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

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

No annotations are provided, so the description carries the burden. It discloses the operation is a read/check and mentions pay-per-call cost ($0.01 USDC), which is useful. However, it does not disclose what happens for non-contract addresses, whether ERC-20 metadata is optional or may be absent, or any error/edge-case behavior. The 'if applicable' is vague.

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 one sentence, front-loaded with the core purpose, and includes the cost note. It is concise and readable. Minor issue: 'if applicable' is slightly vague but not bloated.

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

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

For a single-parameter read tool with no output schema, the description covers the main purpose and cost. However, it lacks detail on return values (bytecode size format, ERC-20 metadata fields) and edge cases (EOA addresses, invalid addresses). Given the simplicity, it is adequate but not complete.

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

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

Schema description coverage is 100%: the only parameter 'address' is described as 'polygon address (0x...)'. The description adds that the tool checks bytecode and ERC-20 metadata, but does not add format details beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('is') and resource ('polygon address'), and mentions checking bytecode size and ERC-20 metadata. It distinguishes from sibling tools like polygon_balance or polygon_token, though it doesn't explicitly name alternatives. The phrase 'if applicable' adds some ambiguity but overall the purpose is clear.

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

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

The description implies usage: call this to check whether an address is a contract and get bytecode size/ERC-20 metadata. It does not explicitly state when to use this vs alternatives, but the sibling list shows other tools for balances, transactions, etc., so an agent can infer. No exclusions or alternative routing are 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?

Annotations are absent, so the description must disclose behavior. It does mention 'Pay-per-call ($0.005 USDC)' which is a cost disclosure. However, it does not clarify read-only nature, rate limits, or response format variations, though the core data returned is explicitly stated.

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, with one informational sentence and a cost detail. It is front-loaded with the core purpose, making it efficient 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?

The core output is clearly defined, but the undocumented 'fields' parameter creates a completeness gap. There is also no mention of how the price is derived or any limitations, though for a simple gas price tool this is partially acceptable.

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

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

The single 'fields' parameter is entirely undocumented in both schema and description. With 0% schema coverage, the description should have explained acceptable values, but it does not mention this parameter at all.

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 returns current polygon gas price in gwei and wei, plus estimated cost for a 21k transfer. This is specific and distinguishes it from other polygon tools (e.g., health, block) by focusing on gas pricing.

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 siblings like base_gas or polygon_health. It does not explicitly state it is for polygon network or any conditions for usage, leaving the agent to infer from the name.

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

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

No annotations are provided, so the description carries the burden. It conveys a read-only network status query and discloses pay-per-call pricing ($0.002 USDC), which is useful behavioral context. However, it does not describe the output shape, possible errors, rate limits, or any other behavioral traits beyond the returned fields.

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 compact sentence that front-loads the tool's purpose, lists the returned data, and includes cost information. There is no filler, repetition, or unnecessary detail.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the main purpose, the data fields returned, and the cost. It is slightly incomplete because exact field-name strings for the subset parameter are not provided, but this is a minor gap for such a low-complexity 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?

Schema coverage is 100% for the only parameter, but the schema only says 'Optional comma-separated subset of fields to return' without specifying valid field names. The description adds meaning by listing the four field categories available: chain id, latest block, gas price, and native token USD price, which helps an agent choose values for the fields parameter.

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

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

The description clearly identifies the tool as a Polygon network health check and enumerates what it provides: chain id, latest block, gas price, and native token USD price. It lacks an explicit verb like 'returns' or 'gets', but the resource and output fields are unambiguous. It is distinguishable from sibling tools like polygon_gas and polygon_block by being an aggregate health endpoint.

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

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

There is no guidance on when to use this aggregate health tool versus the sibling tools polygon_block, polygon_gas, polygon_token, and others. The description does not state exclusions, alternatives, or conditions, so an agent must infer usage from the field list 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. It does disclose a meaningful behavioral trait: pay-per-call cost ($0.01 USDC) and the 'one call' aggregation. However, it does not mention read-only nature, possible failure modes, or what the response contains.

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

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

The description is two short sentences with no wasted words. The core capability is front-loaded, and the cost/usage detail is included compactly.

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 one-parameter, low-complexity balance lookup, the description plus schema is largely complete. It communicates what the tool returns conceptually, the target address, and a key operational detail (cost). Lack of an output schema is not a major gap here.

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

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

Schema description coverage is 100% and the only parameter is already documented as 'polygon address (0x...)'. The description adds no extra parameter semantics beyond what the schema provides, which is acceptable given the 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 specifies the resource (USDC/USDT/DAI balances on Polygon), the target (a polygon address), and the convenience of doing it in one call. It distinguishes itself from sibling tools like polygon_balance (native vs stablecoin balances) and base_stables (different chain).

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 given about when to choose this tool over alternatives such as polygon_balance, polygon_token, or base_stables. The description implies it is for stablecoin balances, but it does not state exclusions or 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?

No annotations are provided, so the description carries the full burden. It discloses the pay-per-call cost ($0.02 USDC) and the live data categories, which are valuable behavioral traits. However, it does not explicitly state that the call is read-only, nor does it mention failure modes, rate limits, or the exact format of returned DEX pairs, leaving some 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 sentence that front-loads the primary output data (price, liquidity, volume, DEX pairs) before adding the onchain metadata and cost detail. Every clause earns its place with no filler or repetition.

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

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

For a one-parameter read tool with no output schema and no annotations, the description covers the essential context: what data is returned, the token scope, and the cost. It is not fully exhaustive—e.g., it doesn't specify the currency of price/liquidity or the number of DEX pairs—but it is sufficient for reliable 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 already describes the only parameter, 'token', as 'polygon ERC-20 token address' with 100% coverage. The description adds 'any' and repeats 'ERC-20', but no new meaning beyond the schema. Baseline 3 applies because 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 tool's function: it provides live price, liquidity, 24h volume, DEX pairs, and onchain name/symbol/decimals for any Polygon ERC-20 token. This distinguishes it from sibling tools like polygon_health or polygon_balance, which cover different resource types. The specific verb 'Live price' implies fetching, and the resource is unambiguous.

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

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

The description gives a clear context for use: 'any polygon ERC-20 token' and the data it returns, which tells an agent when to call it. It does not explicitly name alternatives like base_token for Base chain or exclude non-ERC-20 assets, but the token-specific scope is enough to avoid common confusion.

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?

There are no annotations, so the description carries the transparency burden. It usefully discloses the pay-per-call cost and freshness, but it does not clarify whether the call is read-only, how results are returned, or what side effects or failure modes exist.

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?

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

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

The description is too sparse for a tool with no annotations, no output schema, and an undocumented optional parameter. It never addresses the fields argument, return shape, freshness cadence, or how payment/cost affects retries or data availability.

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

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

The schema has 0% description coverage for fields, and the description does not explain what fields can be passed or what effect the optional fields parameter has. The description adds no meaning beyond the raw parameter name, so the agent is left guessing.

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?

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 says this is a fresh feed for agents, implying a real-time read use case, and the name implies it is the Polygon counterpart to base_trending. However, it never explicitly states when to use it vs. alternatives like base_trending or other polygon data 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 present, the description carries the burden of behavioral disclosure. It adds the pay-per-call cost ($0.01 USDC) and lists output content categories, which is valuable, but it does not explicitly state that the operation is read-only, nor does it mention authentication, rate limits, or error behavior. It neither contradicts annotations (none exist) nor fully covers 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 two sentences with no wasted words. The primary purpose is front-loaded in the first sentence, and the commercial constraint is cleanly appended in the second. 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?

For a single-parameter tool with no output schema and no annotations, this description is largely sufficient: it specifies the input (polygon transaction hash), the output areas (status, block, gas, transfer), and the cost. It does not detail the exact return structure or error cases, but those gaps are minor given the tool's simplicity.

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

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

The schema already fully describes the hash parameter at 100% coverage, so the baseline is 3. The description adds the crucial semantic detail that the hash is for a Polygon transaction, which disambiguates it from EVM-chain sibling tools and gives meaning beyond the raw schema text.

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

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

The description clearly identifies the resource (polygon transaction hash) and the deliverable (status, block, gas, and transfer summary), which distinguishes it from sibling tools like polygon_balance or polygon_block. However, it lacks an explicit verb such as 'get' or 'retrieve,' making it slightly less crisp than a fully specific verb+resource definition.

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

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

The description gives no explicit guidance on when to use this tool instead of alternatives, such as base_tx for Base transactions or polygon_balance for balances. Usage is only vaguely implied by the name and the mention of 'polygon transaction hash'; there are no when-not conditions or sibling references.

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