MACH Base

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

With no annotations provided, the description carries the full behavioral burden. It discloses the operation is a read and adds the concrete cost ($0.003 USDC via x402), which is valuable. It does not mention response format, failure modes, or rate limits, but it does not contradict the read-only implication.

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

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

Two short sentences, with the purpose front-loaded and the cost as a secondary detail. Every word earns its place and there is 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?

For a simple read tool with three required parameters and no output schema, the description covers the operation, network, actors, and cost. It does not specify the return format (e.g., raw uint256 vs formatted) or explicitly explain the token parameter, so it is adequate but not fully complete.

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

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

The schema has 0% description coverage, so the description must compensate for the three undocumented parameters. It clarifies the roles of owner and spender, and 'ERC-20 allowance' implies token is the token address, but the token parameter is not explicitly defined and no unit/format details are provided. Partial compensation only.

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 and resource ('Read an ERC-20 allowance'), specifies the network (Base), and names the relevant parties (owner and spender). This clearly distinguishes the tool from siblings like base_erc20_balance and base_erc20_transfers.

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

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

The description implies when to use the tool (whenever an ERC-20 allowance is needed) but provides no explicit when-not guidance or alternative routing among the many base_* sibling tools. Useful context is present, but exclusions and alternatives are 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?

No annotations are present, so the description carries full responsibility. It discloses the cost ($0.003 USDC) and the 'live' nature, but omits whether the operation is read-only, what happens on invalid block references, authentication requirements, or any rate limits. This is a significant gap 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?

A single sentence that front-loads the action and resource, then adds cost. There is zero waste and every word contributes to 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?

For a simple tool with one optional parameter and no output schema, the description covers the purpose and parameter type. It misses usage guidance relative to siblings and error/edge-case behavior, but given low complexity and the cost mention, it is minimally adequate.

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 shows one optional parameter 'block' accepting string or integer. The description clarifies that the parameter accepts a number or a tag, which adds meaning beyond the schema's type union. However, it does not enumerate valid tags (e.g., 'latest', 'pending'), so coverage remains partial.

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 action ('Return') and a clear resource ('a live Base block header and transaction hashes') with the input dimension ('by number or tag'). It distinguishes itself from siblings like base_block_number (which returns only the number) and base_transaction (which returns transaction details) by its 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 implies usage context ('live', 'by number or tag') but does not explicitly state when to use this tool over alternatives like base_block_number or base_transaction. No exclusion criteria or mention of alternatives is provided, so guidance is minimal.

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 behavioral disclosure, and it does add the material cost of $0.001 USDC and the 'live RPC' source. It does not explicitly state whether the call is read-only or describe any limits, but the return action and cost are the main behavioral factors.

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 filler: the primary action is front-loaded and the cost/payment detail is tucked into the second sentence. Every sentence is informative.

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 zero-parameter tool with no output schema, the description covers the core purpose, the source, and the cost. It is brief but sufficient, although it omits details such as the exact output format and any prerequisites for the x402 payment.

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 zero parameters and the input schema is empty, so there is nothing for the description to add. This matches the baseline for a no-parameter tool.

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

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

The description names a specific verb ('Return') and resource ('current Base mainnet block number'), with the source ('live RPC') adding precision. It is clear what operation this performs, though it does not explicitly contrast with sibling tools such as base_block.

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

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

There is no explicit guidance about when to choose this tool over siblings; the description only states what it returns. The phrase 'current' implies use for the latest block number, but no exclusions or alternatives 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions a cost of $0.003 USDC, which is a useful behavioral detail, but it doesn't explicitly state that this is a read-only operation (though 'check' implies it), nor does it describe the return format or potential errors. Disclosure is minimal.

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 that efficiently conveys the action, resource, and cost. It has zero fluff and 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 simple single-parameter tool, the description covers the core purpose and cost, but it omits the expected return type (boolean), error handling, and any caveats about 'live' data. Given the tool's simplicity, it's adequate but not fully complete.

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

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

The schema provides the address parameter with a regex pattern, but the description adds no semantic information about the parameter beyond calling it 'an address'. With 0% schema description coverage, the description fails to compensate for the lack of parameter guidance.

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

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

The description clearly states the action ('check live Base bytecode') and the outcome (determine if an address is a deployed contract). It's specific and unambiguous, though it doesn't explicitly differentiate from sibling tools like base_contract_info. The purpose is well-defined.

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 when you need to verify if an address is a contract, but it provides no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like base_contract_info. The context is implied rather than stated.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It mentions 'best-effort' and the cost, which are helpful, but it doesn't describe the return format, failure behavior, or what happens if the contract lacks token metadata. 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 two sentences, front-loaded with the core functionality and ending with the cost note. No wasted words; it is efficient and scannable.

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

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

The tool has moderate complexity with no output schema, so the description should hint at return values. It does not specify what metadata is returned or how it is structured, and the 'best-effort' caveat is vague. Given the single parameter and clear scope, it's borderline adequate but leaves room for ambiguity.

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 defines a single address parameter with a regex pattern, which is self-documenting. The description adds no extra meaning about the parameter's purpose or format beyond what the schema provides. Since there is only one parameter, the schema's pattern is sufficient, and the description doesn't degrade it.

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

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

The description clearly states the tool inspects Base contract bytecode, token metadata, and common token interfaces. This is a specific verb-resource combination that distinguishes it from sibling tools like base_contract_code (bytecode only) and token-specific tools like base_erc20_balance.

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

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

The description implies usage for contract inspection and token interface checks but provides no explicit when-to-use guidance or mention of alternatives. An agent might not know when to prefer this over base_contract_code or base_eth_call, though the token metadata aspect adds a distinguishing hint.

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 transparency burden. It discloses that the operation is a read via balanceOf, is scoped to one wallet, and costs $0.003 USDC via x402. It does not mention return format, units, or error behavior, but covers the key behavioral aspects of a simple read 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?

A single front-loaded sentence places the action and object first, then the method and cost. 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?

For a simple two-parameter read with no output schema, the description gives the core information needed to invoke it correctly. It could be more complete by stating whether the balance is returned in raw units or with decimals and by flagging the native-balance sibling, but nothing critical is missing.

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

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

Schema description coverage is 0%, but the description adds role-level meaning: token is the ERC-20 contract and address is the Base wallet. It does not provide units, decimals, examples, or address format guidance, so it only minimally compensates for the missing schema descriptions.

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 begins with a specific verb, 'Read', and a precise resource: an ERC-20 token balance for one Base wallet using balanceOf. This clearly distinguishes it from siblings like base_wallet_balance (likely native balance) and base_erc20_transfers (transfer history).

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 usage context is implied: use this when you need an ERC-20 token balance for a single Base wallet. However, it does not explicitly state when not to use it, such as for native ETH balances, or name an alternative 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?

Annotations are absent, so the description carries the full burden. It discloses the cost ($0.005 USDC via x402), which is useful behavioral context, but does not mention pagination, return format, or whether the query is read-only (though implied). It also leaves 'bounded' undefined, which could confuse agents about result limits.

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

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

A single, front-loaded sentence with no fluff. It conveys the primary purpose and a key cost detail, but the conciseness trades off some explanatory depth.

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

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

With five parameters (one required), no output schema, and no annotations, the description is too thin. It fails to explain what 'bounded' means, how block ranges work, response structure, or any limits. An agent would likely need to inspect the schema and guess at behavior.

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

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

Schema coverage is 0%, so the description must explain parameters. It covers token and the from/to address filters, but omits from_block and to_block entirely. This partial semantic coverage leaves the block range parameters undefined, which is a gap given the low 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 'Query' and the resource 'ERC-20 Transfer events on Base', with the primary filter being 'by token'. It distinguishes from siblings like base_erc20_balance and base_allowance, though the term 'bounded' is ambiguous and doesn't fully clarify scope (e.g., block range limits).

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

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

No guidance on when to use this tool versus alternatives such as base_logs or other event queries. The description only states what it does, not when it is the right choice, nor any conditions like 'use this when you need transfer events with wallet filters'.

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

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

With no annotations, the description carries the burden and does disclose that the operation is read-only and that it costs $0.005 USDC via x402. But it does not disclose return format, default block behavior, failure modes, or any ABI/decoding requirements, 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?

Two short sentences deliver operation, read-only nature, target, block tag, and pricing with no filler. Information is front-loaded and every clause earns its place.

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

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

There is no output schema and no annotation coverage, yet the description never states what an eth_call returns (raw ABI-encoded data), how that return should be decoded, or what the default block is. For a tool with three parameters and a non-trivial return type, this is a material omission.

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 0%, so the description must compensate. It only implies that 'to' is the contract and 'block' is a chosen block tag; 'data' is not explained as calldata or given encoding guidance. This is minimal added meaning over the raw 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 names a specific verb ('Execute') and resource ('Base contract') with a precise operation ('read-only eth_call') and scope ('at a chosen block tag'). This distinguishes it from generic sibling tools like base_contract_code, base_erc20_balance, and base_logs, which target different 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?

The description implies when to use it: whenever a read-only contract call is needed on Base. However, it does not explicitly mention alternatives or provide when-not-to-use guidance despite a large sibling list, leaving route 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 provided, the description carries the full burden. It discloses a cost ($0.001 USDC via x402) and that data comes from a live RPC, which are useful behavioral traits. However, it does not mention error handling, rate limits, or the return type beyond 'wei'. For a simple getter, 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 two short sentences with no filler. The core action is front-loaded, and the cost note is appended as a practical detail. It is appropriately sized for a no-parameter 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 has no parameters and no output schema, the description should cover the return value. It specifies the unit (wei) and source (live RPC), which is sufficient for an agent to understand the result. It does not detail the exact data type (e.g., string vs number) or error scenarios, but for a simple gas price lookup, this is reasonably 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 tool has no parameters, so there is nothing to describe. Per the rubric, a zero-parameter tool gets a baseline of 4. The description adds no parameter information because none is needed.

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 a specific action ('Return') and resource ('current Base gas price in wei from a live RPC'). It is unambiguous and distinct from sibling tools that deal with blocks, balances, or contracts. The addition of 'from a live RPC' adds specificity that differentiates it from any cached or historical gas price tool.

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 does not provide any guidance on when to use this tool versus alternatives or when not to use it. It only states the action and a cost. Since there are many sibling tools, explicit routing context would help, but none is given. The cost note is a practical detail but not usage guidance.

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

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

The description discloses an important behavioral trait: the operation costs $0.005 USDC via x402, which signals a payment requirement beyond normal schema data. However, with no annotations present, it does not explain payment mechanics, result limits, or whether the 'bounded' wording refers to block range limits, maximum returned logs, or something else.

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 primary operation and filters are front-loaded, and the cost detail is a separate, necessary addition.

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

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

There is no output schema and no annotations, so the description should explain what the agent can expect in return and how the paid access works. It does not describe returned log fields, pagination, default block behavior, or how the x402 payment is fulfilled, leaving notable gaps for correct 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?

With 0% schema description coverage, the description must carry parameter meaning, and it does name 'address, topics and block range filters,' which maps to all four parameters. However, it does not clarify topics array semantics, null entries, block inclusivity, defaults, or ordering, so the compensation is only partial.

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

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

The description uses a specific verb ('Query') and names the resource ('Base contract event logs') along with the relevant filter dimensions ('address, topics and block range filters'). It is clear what the tool does, though it does not explicitly contrast itself with sibling tools such as base_receipt, which can also expose logs.

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 about when to use this tool versus alternatives, and it does not mention exclusions or preferred sibling tools. The only context is the cost note; an agent must infer the appropriate use case 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 burden. It discloses the cost ($0.003 USDC via x402), which is a useful behavioral trait. However, it doesn't disclose whether this is a read-only operation, whether it can fail (e.g., invalid address), or what the response format looks like. The cost disclosure adds some value, but the description is thin on behavioral detail.

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 is concise and front-loaded with the action and resource. The cost information is a useful addition and doesn't add clutter. 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 simple one-parameter tool, the description is mostly complete: it states what it returns and the cost. However, it lacks any mention of error conditions, response format, or whether the nonce is pending or latest. Given the simplicity, this is adequate but not thorough.

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 0%, so the description must compensate. The description mentions 'one Base address' but doesn't explain the 'address' parameter format beyond the schema's regex pattern. It adds minimal meaning—just that the address is a Base address. The schema already provides the pattern, so the description adds little beyond that.

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 ('Return') and resource ('current transaction nonce for one Base address'), which clearly distinguishes it from sibling tools like base_block or base_gas_price. It doesn't explicitly name a sibling alternative, but the resource and action are 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 implies usage context: it's for fetching a nonce for a single Base address, and the cost is stated. However, it doesn't explicitly say when to use this vs. alternatives (e.g., base_transaction or base_wallet_balance), nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It does add valuable behavioral context: the $0.005 USDC cost and the 'live' freshness guarantee. However, it does not explicitly state that the operation is read-only or non-destructive, nor does it mention any potential side effects or rate limits. The cost disclosure is a strong positive, but other safety aspects are left implicit.

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 description is one sentence that front-loads the core purpose and then appends the cost. Every word earns its place, and there is no filler. It is appropriately concise for a tool with a single parameter.

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

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

The tool is simple (one parameter, no output schema), and the description covers the return value and cost. However, it does not explain what 'confirmation depth' means or how to interpret the receipt structure. It also lacks any usage context or error behavior. For a simple tool this is acceptable but leaves room for improvement.

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 0%, and the description does not mention the tx_hash parameter at all. The schema provides only a pattern, not semantic meaning. The description adds no explanation of what the hash represents or any format guidance beyond the regex. With zero coverage, the description should compensate, but 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 uses a specific verb ('Return') and names the resource ('live Base transaction receipt') plus a distinguishing detail ('current confirmation depth'). This clearly separates it from siblings like base_transaction and base_block, which likely focus on different data. No ambiguity about what the tool does.

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 on when to use this tool versus its siblings, such as base_transaction or base_logs. It does not state any conditions or exclusions. An agent would have to infer from the name and description alone, which is insufficient for selecting between 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 the behavioral burden. It discloses that the operation is a read and explicitly states the cost and payment method ($0.003 USDC via x402), which is useful. However, it does not mention potential failure modes, authorization requirements, or absence of state changes beyond the word 'Read'.

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

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

Two short sentences with no filler. The core operation is stated immediately and the pricing detail is added without bloat.

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 tool, the description conveys the token standard, network, and cost. It does not describe the return format, but the tool name and 'Read totalSupply' make the expected result clear enough for a basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'token' parameter. It does so by specifying that the token must be an ERC-20 or ERC-721 contract, giving meaning beyond the raw schema pattern.

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

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

States a specific verb ('Read'), a concrete resource ('totalSupply'), and the contract standards ('ERC-20 or ERC-721') and network ('Base') it applies to. This clearly distinguishes it from sibling tools such as balance, transfer, or contract info 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 implies when to use the tool: whenever an agent needs the totalSupply of an ERC-20 or ERC-721 contract on Base. It does not explicitly name alternatives or exclusions, but the use case is clear enough for a simple read operation.

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 live nature of the data, the specific fields returned, and the $0.008 USDC cost via x402. However, it does not mention behavior for a nonexistent or unconfirmed transaction, response structure, or any rate limiting.

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

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

Two short sentences, front-loaded with the main purpose and followed by the cost. Every word adds information and there is no 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 lookup tool, the description is mostly functional: it names the resource, the parameter, the returned data, and the cost. But with no output schema and no annotations, missing details like not-found behavior and response formatting leave notable gaps.

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

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

The description only repeats 'by hash' and does not add meaning beyond the schema's tx_hash property and pattern. Since schema description coverage is 0%, the description was expected to compensate, but it fails to explain the hash format or provide any additional context.

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 ('Return'), the resource ('live Base transaction'), and the lookup method ('by hash'), and lists the returned fields (sender, recipient, value, calldata). It is specific enough to be understood, though it does not explicitly contrast with the closely related base_receipt sibling.

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 given about when to choose this tool over base_receipt or other base_* siblings. The description implies a hash lookup but does not state exclusions, prerequisites, or alternative 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 provided, the description carries the full burden of behavioral disclosure. It explicitly says 'Read', which implies a non-destructive, read-only operation, and it discloses the cost ($0.003 USDC via x402). This adds value beyond the schema. However, it does not describe the response format, what happens on invalid input or errors, whether the balance is returned in wei or ETH, or any rate limits or caching behavior. For a simple read tool, this is adequate but not thorough.

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 the core purpose front-loaded and the cost information as an important secondary detail. Every word earns its place; there is no padding or redundancy. This is exemplary conciseness for a tool with a single parameter.

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 of this simplicity (one parameter, no output schema), the description is mostly complete in stating what it does. However, it fails to specify the return value format (e.g., balance in wei vs ETH, decimal precision), which an agent would need to correctly interpret the result. It also does not mention any edge cases like zero balance or invalid address handling. Since there is no output schema, this gap is more significant, making the description only partially 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 0%, so the description must compensate. The only parameter, 'address', is referenced only as 'one Base address'. This adds the chain context (Base) but does not explain the required format beyond what the schema pattern shows, nor does it mention that the address is a string, checksummed, or that it must be a valid 0x-prefixed address. The description adds minimal semantic value over the parameter name itself.

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

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

The description uses a specific verb ('Read') and a specific resource ('native ETH balance for one Base address'), which immediately distinguishes it from siblings like base_erc20_balance (ERC-20 tokens) or base_wallet_snapshot (likely a broader overview). The phrase 'native ETH' makes the tool's scope unambiguous, and 'for one Base address' signals the singular input.

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 intended use case is clear and implied by the purpose: if you need the native ETH balance of a Base address, this is the tool. However, the description does not explicitly state when to prefer this over alternatives (e.g., base_erc20_balance for tokens, base_wallet_snapshot for a full wallet view), nor does it mention any exclusions or prerequisites. The cost note hints at usage considerations but does not provide comparative guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses a cost ($0.003 USDC via x402) and the read-only nature via 'Read', which is valuable. It also notes the token limit. However, it does not mention error handling, rate limits, or the return format, which would improve 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 concise sentences with no fluff. It front-loads the core function and appends the cost, which is relevant for agent decision-making. Every word adds value.

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

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

The tool is simple with only two parameters and no output schema, so the description covers the primary purpose and cost. However, it omits the return value structure, error behavior, and the optional nature of 'tokens', which could lead to incorrect assumptions about the response format. Given no annotations, this is a moderate gap.

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?

With 0% schema description coverage, the description must compensate. It explains that 'address' is the wallet and 'tokens' are ERC-20 contract addresses, and that up to 10 can be supplied. However, it does not explicitly state that 'tokens' is optional or describe the address format beyond the schema pattern, leaving some ambiguity.

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

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

The description states a clear verb ('Read'), a specific resource (native ETH plus ERC-20 balances for one Base wallet), and a limit (up to 10 tokens). It distinguishes itself from siblings like base_wallet_balance (native only) and base_erc20_balance (single token) by emphasizing the multi-token snapshot capability.

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

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

The description implies usage for reading multiple balances at once, but does not explicitly mention alternatives or exclusions. There is no 'when to use this vs. base_wallet_balance' guidance, so the agent must infer the differentiation 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.