Aether: Base onchain data & token risk (x402)

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

Annotations only declare readOnlyHint and openWorldHint; the description adds materially more — deterministic rule-based processing with no AI, rejection of secret-bearing input, and the $0.01 USDC on Base x402 payment requirement, which is critical auth/billing context. It also discloses the shape of the output (findings plus fixes), which annotations do not cover.

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?

Roughly 55 words across short sentences, front-loaded with the core purpose and then progressively adding input limit, output, constraints, and price. No sentence is redundant; even the disclaimer and pricing serve selection and setup decisions.

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

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

With no output schema, the description correctly describes the returned findings and includes the payment and rejection behaviors an agent needs before calling. The gap is the undocumented 'request' parameter, which nothing else in the definition explains.

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 carry the load. It documents the 'text' parameter well (write-up content, up to 40,000 characters, matching maxLength), but the second parameter 'request' (500 chars) is never explained, leaving half the parameters undocumented in both schema and description.

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

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

The opening question plus the explicit output list ('claims that cite no evidence, contradictions, missing evidence and documentation gaps, with fixes') states a specific verb and resource. It is unmistakably distinct from the wallet/chain siblings (base_*) and from score_opportunity or triage_invoice; an agent knows this audits a written document for evidentiary support.

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

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

It gives clear triggering context ('Does this write-up back up what it claims?') and two scope exclusions: it is a documentation review, not legal/financial advice, and it rejects text containing secrets. It does not name an alternative tool or say when a different audit sibling should be chosen instead, so it stops short of full routing 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?

Annotations give readOnlyHint/openWorldHint, and the description adds genuinely non-obvious behavior: the full validation checklist, the tri-state outcome with a 0-100 score and per-failure fix, and the monetary cost ($0.01 USDC on Base via x402). Cost disclosure is high-value context the annotations do not carry, though failure modes like unreachable URLs or timeouts are not 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?

A single tight paragraph that front-loads the purpose, then the validation scope, then the return shape, then the price. Every sentence carries information an agent needs and nothing is padded.

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

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

With no output schema, the description compensates by describing the pass/warn/fail result, score, and fix output, plus the invocation cost. It slightly undersells how the optional expect object changes failure determination, but overall it is complete enough to call correctly.

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

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

Schema description coverage is 100%, so the schema already documents url, body, expect, method and headers. The validation list loosely maps to the expect fields (network, asset, price) but adds no syntax or semantic detail beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb and resource ('audit x402 payability of a paying agent's API') and enumerates exactly what it validates (CAIP-2 network, USDC asset, payTo checksum, amount, EIP-712 domain, resource URL, Bazaar discovery). No sibling tool covers this ground, so differentiation is implicit and strong.

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

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

Usage context is clearly implied ('Probes any x402 URL' to check whether a paying agent can actually pay it), but there is no explicit when-not guidance or named alternative among the many base_*/audit_* siblings. The price note hints at a decision factor but does not route the agent.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new operational context: the x402 payment model and its cost ($0.002 USDC on Base), plus the fact that the result includes an unlimited-approval flag. It stops short of describing failure modes or latency.

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

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

Three short sentences: purpose first, then usage timing, then inputs and price. Every sentence carries distinct information and nothing is repeated from the schema.

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

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

For a simple read-only tool with no output schema, the description covers purpose, call timing, inputs, and cost. It partially characterizes the return ('how much', 'whether unlimited') but does not specify the exact response shape or units, which is the only notable 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?

Schema description coverage is 0%, so the schema contributes only names and address patterns. The opening sentence defines the roles indirectly (owner holds the balance, spender is approved by owner, token is the ERC-20), which is real added meaning, but the input list itself ('Input: token, owner, spender') adds nothing and no parameter is explained individually.

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

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

Names a specific verb and resource ('ERC-20 allowance check on Base') and states exactly what the result answers: how much a spender may still move from an owner's balance and whether the approval is unlimited. This cleanly separates it from siblings like base_erc20_balance or base_token, which read different state.

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

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

Gives explicit timing guidance: 'Run before a swap, an approve or a revoke.' That is clear context for when the tool is appropriate. It does not name an alternative tool or state when this is the wrong choice, so it falls short of a 5.

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 already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely new behavioral context beyond the annotations: the read is live from chain (freshness) and the call is paid ($0.001 USDC on Base via x402), which the agent must know before invoking.

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

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

Three short, front-loaded sentences: what it reads, what it takes, what it costs. No filler or redundancy.

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

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

Covers purpose, input and price, which is decent for a single-param tool. However, with no output schema it never states the return format or units (wei vs ETH, string vs number), and the payment mechanics behind 'x402' are only name-dropped, leaving the caller to infer how to complete a paid call.

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

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

Only one parameter, and the schema gives the 0x-address pattern while carrying no description text. 'Input: address' largely restates the schema, but 'any address' adds a real semantic point: it is not limited to the caller's own wallet.

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

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

States a specific verb and resource: the native ETH balance of any address on Base, read live from chain. 'Native ETH' implicitly separates it from base_erc20_balance and base_portfolio, though no sibling is named explicitly.

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

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

Usage is implied by the purpose (read a wallet's ETH balance), and the $0.001 USDC price gives the agent a cost signal relevant to deciding whether to call. But there is no explicit when-to-use, when-not-to-use, or alternative named (e.g., erc20 vs native).

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 only declare readOnlyHint and openWorldHint; the description adds the crucial fact that this call costs $0.01 USDC on Base via x402, plus the returned fields (address, avatar, profile text records). That payment/return context goes meaningfully beyond the annotations, though latency or failure modes for the payment flow are unstated.

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

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

Three compact, front-loaded sentences with no filler; the purpose leads and the price/return details follow. The 'Input: name' clause is slightly redundant with the schema but negligible.

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

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

With no output schema, the description correctly names what comes back (wallet address, avatar, profile text records) and discloses the x402 payment cost. For a one-parameter read tool this is nearly complete; only the payment/error flow is unspecified.

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% and there is a single required 'name' parameter, so the description must carry the load. It supplies a format example ('jesse.base.eth') which helps, but does not cover the 3-100 character constraints or normalization rules beyond what the schema implies.

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

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

States a specific verb and resource ('resolve a Base name ... to its wallet address') and gives a concrete example ('jesse.base.eth'). This is clearly distinguishable from the numeric/state-reading siblings like base_balance or base_token.

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

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

Usage is implied by the single-purpose lookup framing, but there is no explicit when-to-use, when-not-to-use, or named alternative among the many base_* siblings. An agent can infer the intent, but nothing routes it explicitly.

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 cover the read-only and open-world nature of the call, and the description adds non-obvious behavior: the call is metered at $0.01 USDC on Base via x402. Cost/payment disclosure is real added value beyond the annotations, though the mechanics of the payment flow itself are not 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?

Two short sentences, front-loaded with the lookup scope and output fields, followed by the pricing note. No filler or restatement of the tool name.

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

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

For a single-parameter read tool with no output schema and light annotations, the description supplies the accepted inputs, the tags, the key return fields, and the cost. It omits details such as whether unnamed/default behavior exists when 'block' is omitted, which the empty required list makes relevant.

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 carry the parameter burden. It does so by documenting that 'block' accepts either a numeric block number or a named tag, and it enumerates the valid tags (latest, safe, finalized), which the schema alone 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?

States a specific verb and resource ('block lookup by number or tag') and enumerates the returned fields (timestamp, gas, transaction count), which clearly separates it from siblings like base_tx or base_receipt. An agent can identify the tool without opening the schema.

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

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

There is no explicit guidance on when to use this versus alternatives such as base_tx, base_receipt, or base_gas. The only usage-adjacent information is the accepted input forms (number or tag), which is closer to parameter documentation than selection 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuine extra context beyond that: it returns either the raw result or the revert reason, and it discloses a cost ($0.01 USDC via x402) which the annotations do not convey.

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

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

Three sentences, front-loaded with the core operation followed by usage and cost. No filler; every sentence carries distinct 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?

It covers return behavior, dry-run use, and cost, which matters since there is no output schema. However, for a four-parameter tool with zero schema description coverage, the omission of any parameter meaning leaves a real gap 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?

Schema description coverage is 0% across four parameters (to, data, from, value), and the description says nothing about any of them. With no schema prose to lean on, the description should explain at least the required to/data pair, 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?

States a specific verb and resource ('simulate a read-only contract call on Base (eth_call)') plus scope ('without sending a transaction'). An agent can distinguish this from sibling base_estimate_gas or base_tx because the eth_call semantic and read-only nature are explicit.

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

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

Gives clear usage context: 'Use it to dry-run a call before signing.' That tells the agent when to reach for it, but names no alternative tools and states no exclusions.

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

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

Annotations already cover readOnlyHint and openWorldHint, but the description adds meaningful context the annotations do not: the returned fields (code size, proxy implementation, token standards) and, critically, that this is a paid call at $0.01 USDC via x402. Disclosing cost is real behavioral value.

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

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

Two compact sentences, front-loaded with the core question and the returned attributes, with pricing tacked on at the end. Efficient, though the pricing clause could be better integrated.

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

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

With no output schema, the description takes on the return-value burden and does so by listing the classified fields. It also surfaces the paid nature of the call. Only the address-format and any output structure detail are left implicit.

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 with 0% schema description coverage, so the description carries the burden. It identifies the input as 'this Base address', but adds no detail on format or meaning beyond the name; the schema's regex pattern is what actually conveys the expected shape.

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 (a Base address) and enumerates what the tool determines: EOA vs contract, code size, proxy implementation, and ERC-20/721/1155 detection. This distinguishes it from balance/token/transfer siblings, though it never names an alternative to route against.

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

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

It frames the use case as a question ('What is this Base address?') which implies when to reach for it, but gives no explicit when-to-use/when-not guidance and never contrasts it with siblings like base_token, base_nft_metadata, or base_balance that an agent must disambiguate from.

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 cover read-only and open-world, but the description adds genuinely new facts: the result is formatted with token symbol and decimals (no output schema exists), and the call is a paid x402 endpoint costing $0.002 USDC on Base. That payment/auth context is not derivable from any structured field, though error and failure behavior go unmentioned.

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

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

Three short sentences, front-loaded with what the tool returns before inputs and price. The middle 'Input:' sentence restates the schema's two property names and is the only mildly expendable line.

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 supplies output formatting, the two inputs, and the payment model. Coverage is solid; only failure modes and any rate/latency expectations are 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 coverage is 0%, so the schema gives only names and a hex pattern. The description compensates partially by clarifying address = wallet address and token = token contract address, but adds no detail on the expected ERC-20 contract semantics or chain caveats.

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

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

States a specific verb+resource: the ERC-20 token balance of a wallet on Base, and clarifies it covers any token, not just USDC. This implicitly separates it from base_balance (native asset) and base_allowance, though it never names those siblings outright.

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

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

The description only says which inputs to supply; it gives no conditions for choosing this tool over base_balance, base_portfolio, or base_allowance, and no exclusions. An agent must infer that ERC-20 vs native balance is the dividing line.

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 already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely new behavioral context: it returns cost in both ETH and USD, and it is a paid call at $0.002 USDC on Base via x402 — a billing detail no annotation conveys.

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

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

Three tight sentences, front-loaded with the core purpose and ending with pricing. Nothing is padded, though the input clause is ambiguous in a way that costs clarity rather than saving space.

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

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

With no output schema, the description does name what comes back (gas, ETH cost, USD cost), and it discloses the payment model. It is close to complete for a simple estimation tool, with the required/optional input mismatch being the main 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?

Schema coverage is 0%, so the description carries the full burden, and it only lists parameter names. Worse, it says 'to, and optionally from, data and value' while the schema marks both 'to' and 'from' as required, which can mislead the agent about what it must supply. No format or unit guidance (hex addresses, value denomination) is given.

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

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

States a specific verb and resource: estimating gas plus ETH/USD cost for a Base transaction, and scopes it to 'before signing it'. This distinguishes it from network-level siblings like base_gas, though it never names an alternative explicitly.

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

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

The phrase 'before signing it' implies the pre-flight use case, which is real guidance. However, it never states when to prefer this over base_gas, base_call, or base_receipt, nor 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?

Annotations already establish readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful context beyond that: the data is read live from the chain (freshness) and the call costs $0.01 USDC via x402, which is a material behavioral fact an agent should know before invoking.

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, both earning their place: the first front-loads purpose and returned fields, the second discloses the payment cost. 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?

With zero parameters, no output schema, and annotations covering safety, the description supplies everything an agent needs: what is returned, the unit, that it is live chain data, and the invocation cost. Nothing material is missing for a tool of this 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 tool takes no parameters, so the baseline is 4 and there is nothing for the description to clarify. It correctly lists the returned fee components and their unit (gwei), but that is output rather than parameter semantics.

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 resource and what it returns: current Base gas price in gwei with base fee, priority fee, and max fee per gas, read live from chain. This is clearly distinguishable in substance from base_estimate_gas (which estimates a transaction's gas), but the description never names or explicitly contrasts that sibling, 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?

Usage is implied by the content (fetch live fee data before sending a transaction), but there is no explicit when-to-use statement, no mention of the alternative base_estimate_gas, and no stated preconditions. Adequate but leaves routing 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?

Annotations cover read-only and open-world traits, and the description adds genuinely useful behavior beyond them: the tool is paywalled ($0.005 USDC on Base via x402) and it will resolve URIs across IPFS, Arweave, data URIs and https, which signals possible resolution failures or latency. It does not contradict the annotations.

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?

One dense sentence that front-loads the resource and output, followed by a short payment clause. No filler, and the price is the single most consequential operational fact for an x402 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?

There is no output schema, so the description correctly enumerates the return shape (token URI plus resolved name, image, attributes) and flags the paid invocation path. Remaining gaps are parameter format and sibling routing rather than missing return or safety information.

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% for both required params, so the description carries the full burden. It conveys that a contract and token are involved and constrains the contract to ERC-721/ERC-1155, but never states that contract is a 0x address or that tokenId is a decimal string, leaving the pattern-only schema unexplained.

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

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

States a specific verb+resource: resolves NFT metadata (token URI, name, image, attributes) for an ERC-721/ERC-1155 token on Base. Clear scope, but it never names or contrasts with the closely related sibling base_nft_owner or base_token, so an agent must infer the split itself.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. It implicitly says 'call this when you need metadata', but nothing distinguishes it from base_nft_owner (ownership) or base_token, both of which an agent could plausibly pick for the same contract/tokenId pair.

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 already cover the safety profile (readOnlyHint, openWorldHint), so the bar is lower. The description adds genuinely useful behavioral context the annotations don't convey: the call costs $0.01 USDC on Base via x402, and it maps to the on-chain ownerOf read. Return format is not detailed, but for a simple owner read this is strong.

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?

Front-loaded with the core question ('Who owns this NFT?'), followed by a precise technical clause and the pricing note. Every sentence earns its place with 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 two-parameter, read-only lookup with no output schema, the description implicitly conveys the return (the owner) and discloses the payment requirement and chain. Little is missing; a note on the response shape for non-existent tokens would make it 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 carry parameter meaning. It names both inputs — 'contract address' and 'token id' — which maps them to their roles, but adds no further depth (formats are enforced only by schema patterns). Adequate but not compensating richly for the coverage gap.

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

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

States a specific verb and resource — the current owner of an ERC-721 token — and names the exact method (ownerOf), the chain (Base), and the lookup keys (contract address, token id). This is clearly distinguishable from siblings like base_nft_metadata, which returns metadata rather than ownership.

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

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

There is no explicit when-to-use or when-not guidance, nor any mention of the alternative tools (e.g., base_nft_metadata). The x402 pricing note implies a paid single call, but the agent gets no signal about when this tool should be preferred over a broader portfolio/transfer lookup.

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 already establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavioral context beyond the annotations: the pricing source (live DEX prices) and, critically, that the call costs $0.004 USDC on Base via x402 — a payment requirement an agent must know before invoking.

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

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

Three compact sentences, front-loaded with the value proposition, then input, then cost. Every clause carries information (token default, price source, payment) 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?

With no output schema, the description does explain the return shape (each holding priced in USD, plus total) and covers input and payment cost. It is essentially complete for an agent to call it; only edge behavior (e.g., invalid address or unpriced tokens) is unspecified.

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 carry the load, and it largely does: 'address' is identified as the wallet address input and 'tokens' is explained as an optional set of up to 20 tokens you choose, with ETH plus major tokens as the default when omitted. Only the address format is left to the schema's 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+resource ('Wallet portfolio value on Base') and enumerates exactly what comes back: per-holding USD prices from live DEX prices plus the total. This clearly separates it from single-value siblings like base_balance, base_erc20_balance, and base_price.

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

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

Usage is implied by the purpose — you call it when you want a full wallet valuation — and it names the required input ('Input: wallet address'). However, it never explicitly says when to prefer this over base_balance or base_erc20_balance for a single token, and gives no prerequisites or exclusions.

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

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

Annotations cover the read-only and open-world profile, and the description adds material behavior beyond them: the call is paid ($0.003 USDC on Base via x402), which is critical for an agent to know before invoking. It also signals coverage limits (requires a DEX pool), though it omits rate limits or failure behavior.

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

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

Three tight sentences, front-loaded with what the tool returns, followed by scope and cost. Every sentence carries information; the pricing sentence is arguably dry but operationally necessary.

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

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

For a read-only single-parameter tool with no output schema, the description covers the return payload (price + liquidity), source venues, coverage scope, and payment requirement. Only the detailed response shape is left implicit, which is acceptable given no output schema is declared.

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% (no per-parameter descriptions), but the description compensates by establishing that the single input is a Base token contract address and even supplies the ERC-20-style context behind the schema's 0x+40-hex pattern. The one required parameter is unambiguous from the prose.

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 and verb-equivalent (retrieve live token price on Base) and adds exactly what is returned: USD price and pool liquidity from Uniswap v2/v3 and Aerodrome. It implicitly separates itself from its sibling base_token (generic token data) by naming the price/liquidity scope, though it never names an alternative explicitly.

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

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

"Works for any token with a DEX pool, including newly launched ones" gives real context on applicability, implying failure for tokens without a DEX pool. However, it gives no explicit when-not-to-use guidance and never routes to alternatives such as base_token or base_token_risk.

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 already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real behavioral context beyond that: it discloses the decoded Transfer-event output and, unusually, the exact cost ($0.003 USDC via x402), which matters for an agent deciding whether to invoke a paid endpoint. It stops short of noting auth/payment flow details or behavior on an unknown hash.

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, both earning their place: the first front-loads the purpose and output shape, the second front-loads the price. No filler, no restatement of the name.

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

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

With no output schema, the description does the work of explaining the return value (status, gas, decoded Transfer events), which is the most important gap to cover for a single-param tool. Remaining gaps are minor: no note on behavior for pending/nonexistent hashes and no sibling differentiation.

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

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

Only one parameter (hash) with 0% schema description coverage, so the description carries the burden. 'By hash' signals the argument is a transaction hash and the schema's regex enforces the 0x-64-hex format, but no further semantics (chain scoping, what happens on a nonexistent hash) are given.

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

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

States a specific verb+resource (returns a Base transaction receipt by hash) and enumerates exactly what it contains: success/reverted status, gas used, and decoded ERC-20 Transfer events. It is immediately clear what the tool returns, though it never names or distinguishes itself from the sibling base_tx, which likely also takes a hash.

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

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

There is no explicit when-to-use guidance, no exclusions, and no alternatives named. The enumerated return contents imply the tool is for inspecting a confirmed transaction's outcome, but with base_tx and base_transfers present as siblings, an agent gets no help deciding between them.

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 already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful non-annotation context: this call is paid, costing $0.01 USDC on Base via x402, which an agent needs before invoking. It stops short of describing failure modes (non-ERC-20 address, unverified contract) or any rate/limit behavior.

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

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

Two sentences, zero filler. What the tool returns is front-loaded, and the payment detail follows as a distinct, necessary second fact.

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 returned fields, the chain, the token standard, the keying parameter, and the cost of the call. Only error/edge-case behavior is unstated, which is a minor gap at this complexity level.

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 carries the burden. It clarifies that the single 'token' parameter is a contract address on Base identifying an ERC-20, which adds semantic meaning beyond the bare 0x{40} pattern in the schema. It does not clarify what happens with a non-ERC-20 or EOA address.

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 resource and scope: ERC-20 token metadata on Base, keyed by contract address, and enumerates exactly what comes back (name, symbol, decimals, total supply). That field list implicitly separates it from siblings like base_token_risk (risk scoring) and base_erc20_balance (holder balance), so an agent can route without opening either schema.

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

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

The description makes the usage context clear (any ERC-20 on Base, addressed by contract address) but never states when to pick this over base_token_risk, base_erc20_balance, or base_contract, nor any preconditions. Usage is implied by the resource scope rather than stated, which is the definition of a 3.

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 declare readOnlyHint=true and openWorldHint=true, but the description adds substantial context beyond them: exactly which powers are inspected (mint, blacklist, pause, fee, proxy upgradeability, owner, DEX liquidity), that a real buy/sell is simulated, the return shape (verdict + 0-100 score + evidence), rate limits (3/day trial), and pricing ($0.01 USDC via x402). The simulation is clearly off-chain, so readOnlyHint is consistent, not contradicted.

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?

Front-loads the agent's actual decision ("Is this token safe to buy?") before the mechanics, then layers inputs, outputs, usage, trial, and price in a tight sequence. Every sentence carries operational value for an agent deciding whether and how to call it.

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

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

With no output schema, the description correctly supplies the return contract (verdict enum, 0-100 score, supporting evidence). Combined with the trial endpoint and x402 payment details, an agent has everything needed to invoke it, pay, and 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?

Schema description coverage is 100%, so both parameters are already documented in the schema; the description only restates "Input: token address" and implies the simulation step without adding format or behavior nuance beyond the schema's own "Run the buy/sell simulation (default true)". Baseline 3 applies when the schema does the heavy lifting.

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

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

Opens with a specific question that names the resource (Base token) and the exact risks it evaluates (honeypot, rug pull, scam), then states the mechanism: buy/sell simulation, tax measurement, mint/blacklist/pause/fee/proxy/liquidity checks. This clearly separates it from siblings like base_token (raw metadata) and base_token_risk_trial (the free trial variant).

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?

"Check before an agent trades a token" gives an explicit trigger condition, and the trial endpoint is named as a free alternative (3 calls/day). It stops short of stating when not to use it (e.g. non-Base chains, non-ERC-20 tokens) or how it relates to base_token_risk_trial by tool name rather than URL path.

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 only cover readOnlyHint and openWorldHint; the description goes well beyond them by disclosing a hard rate limit (3 calls per caller per day), the absence of payment/wallet requirements, and the exact scope of the analysis performed (simulation, tax, mint, blacklist, pause, owner, liquidity). This is behaviorally rich and consistent with readOnlyHint=true since it is an inspection-style trial.

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?

Front-loads the value proposition and the free/rate-limit terms before the mechanics and the cross-sell. It is dense and parenthetical-heavy, but nearly every clause carries information; only minor tightening is possible.

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 2-parameter inspection tool with no output schema, the description covers what is checked, the cost model, the rate limit, and the follow-up tool, which is everything an agent needs to select and call it correctly.

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

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

Schema coverage is 100%, so both parameters (token, simulate) are already documented in the schema. The description adds only 'Input: token address' and says nothing about the simulate flag, so it does not meaningfully extend schema semantics. Baseline 3 applies.

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

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

The description uses a specific question framing ('is this Base token safe to buy, or a honeypot, rug pull or scam?') and enumerates the checks performed (buy/sell simulation, tax, mint, blacklist, pause powers, owner, liquidity). It explicitly names the sibling it mirrors (base_token_risk) and how it differs (free trial), so an agent can distinguish it from the paid version without opening either schema.

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

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

Explicitly states when to use it (free, no wallet or payment needed, 3 calls per caller per day) and names the alternative for continued use ('After the trial, use base_token_risk ($0.01 via x402)'). Both the condition and the successor tool are spelled out.

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 already establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond them: a 100-result cap, a 2,000-block scan ceiling, and an explicit price of $0.01 USDC via x402, which an agent must know before calling. Return shape and pagination behavior remain unstated.

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 that packs scope, filters, limits, and cost with no filler. It is dense to the point of being run-on, but every clause carries 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?

With no output schema, the description does sketch the return shape ('who sent how much to whom') and covers the key operational facts an agent needs: scan window, result cap, and payment requirement. Missing details on output fields and ordering keep it short of fully complete.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it does partially: token = the ERC-20, address = the wallet, blocks = the recent-block scan window (up to 2,000). It never clarifies that 'blocks' is a lookback count rather than a range, nor the format/precision of the address filter, leaving real gaps at 0% 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?

States a specific verb and resource ('Recent ERC-20 transfers on Base') plus the entity shape ('who sent how much to whom') and the filter dimensions (token, wallet, or both). This distinguishes it cleanly from siblings like base_tx (single transaction), base_erc20_balance (balance), and base_token (metadata).

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

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

The phrase 'for a token, a wallet, or both' implies the valid filter combinations, which is useful usage guidance. However, it never says when to prefer this over base_tx, base_receipt, or base_portfolio, nor any exclusion conditions, so usage remains inferred 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?

Annotations cover read-only and open-world behavior, and the description adds meaningful context: cost ($0.01 USDC) and payment via x402 on Base. It does not cover rate limits or error modes, but the auth/cost detail is valuable beyond annotations.

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, front-loaded with purpose and return fields, then cost. No redundant text; every sentence 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?

With no output schema, enumerating return fields is essential and the description does that, plus payment details. Missing hash format and error behavior are minor for a simple lookup 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 description coverage is 0% for the single required parameter. The description says 'by hash', implying a transaction hash but not its format or role beyond the schema pattern, so it adds some meaning but leaves the parameter under-explained.

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 ('lookup') and resource ('Base transaction') and enumerates key return fields, which distinguishes it from balance/block tools. It stops short of explicitly contrasting with the sibling base_receipt, so it is not a full 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?

Usage is only implied by 'lookup by hash' and the sibling list. There is no explicit when-to-use guidance, no alternatives, and no exclusions (e.g., versus base_receipt or base_call).

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 only cover readOnlyHint and openWorldHint; the description goes well beyond by disclosing determinism ('same input always gives the same score'), the advisory limitation, and the exact cost and payment rail ($0.01 USDC on Base via x402). Cost and determinism are exactly the behavioral facts an agent needs before calling.

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

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

Four sentences, front-loaded with the core question and then the mechanics, verdict, determinism, disclaimer and price. The rhetorical opening line is the only slight indulgence; everything after it 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?

With no output schema, the description does explain the return conceptually (0-10 plus a three-way verdict) and flags the payment requirement. The remaining gap is that it doesn't say whether a pillar-level breakdown comes back, which an agent reporting results would want.

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 carries the whole burden. It partially compensates by explaining that pillars are scored across seven dimensions and that stage weighting and red flags drive the result, which gives the arrays meaning, but it never says what an individual pillar entry looks like or what the 1-15 redFlagIndices refer to.

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

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

States a specific verb and resource ('scores an opportunity'), names the mechanism (seven pillars weighted by stage), and specifies the output (0-10 score with pass/investigate/fail). An agent can tell this apart from the base_* and audit_* siblings immediately.

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

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

It frames the tool's role ('a screening aid, not investment advice') and the applicable range (pre-seed to Series B+), which implies when it fits, but never states when to use it versus alternatives or what disqualifies an opportunity from being scored here.

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 already cover readOnly/openWorld, so the description's additions matter: it discloses determinism ('no AI: the same input always gives the same answer') and a concrete payment requirement ($0.01 USDC on Base via x402). Those are real behavioral facts an agent needs, though error behavior and the set of aging categories are left unstated.

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 front-loaded, moving from purpose to inputs to output to behavior to price in a compact block. 'Deterministic rules, no AI' and 'the same input always gives the same answer' are slightly redundant but each still 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, so the description correctly explains the return (aging category plus next action) and adds determinism and pricing context. It is essentially complete for a stateless read tool, missing only detail on the category taxonomy.

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 the parameter burden and it does partially by naming all four inputs (invoice number, client reference, amount, days overdue). However it adds no format or unit guidance, leaving ambiguities such as the meaning of a negative daysOverdue (schema allows -365) unexplained.

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 action (triage an overdue invoice), its inputs, and its outputs (aging category and next action), which clearly separates it from the base_* and audit_* siblings. It stops short of any explicit sibling differentiation, but the invoice-triage purpose 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 framing question ('Which overdue invoice should be chased?') implies the use case, but there is no explicit when-to-use, when-not-to-use, or alternative named. Usage is only inferred from the rhetorical setup.

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