Agent Data API

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

With no annotations, the description carries the full burden and does so: it discloses the return content on match (entity, programs, listing date) vs not-found, the additional wallet/contract classification per chain, the 'not legal advice' caveat, and the payment/auth requirement ($0.005 USDC on Base via x402). These are the behavioral details an agent needs and cannot infer from schema.

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?

Dense and front-loaded with the core question and scope before the return/payment details. Slightly long with parenthetical chain lists and 'and others', but every sentence carries information an agent needs.

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 no-annotation, no-output-schema tool, the description is nearly complete: it explains match/not-found return semantics, the classification add-on, and cost. Minor gap is no explicit signaling of failure/error behavior or rate limits, but coverage is strong.

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 baseline is 3. The description's mention of supported chains duplicates the chain enum documentation, but adds no format/syntax detail beyond what the schema already states for address and chain defaults.

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 and verb+resource: screens a crypto address against the OFAC SDN digital currency list. Clearly distinct from sibling wallet/contract/balance tools, so an agent knows this is the sanctions check, not a profile lookup.

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

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

Gives clear context for when to use it (sanctions screening of an address, per-chain wallet/contract classification) and which chains are supported. Does not explicitly compare against related tools like token_risk_check or prepayment_safety_check, so no exclusions/alternatives are 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 full behavioral burden and adds important context: it discloses the $0.005 USDC x402 cost on Base and lists the detailed information returned. It does not explicitly state read-only behavior or rate limits, but 'Identify' and 'contract_info' strongly imply a read operation.

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

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

The description is one dense but well-structured sentence that front-loads the core purpose and then lists the returned dimensions. Every item in the list earns its place by telling the agent what information is available, and the cost disclosure is appended without unnecessary preamble.

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 one simple parameter, no output schema, and no annotations, the description is complete enough for correct invocation. It explicitly lists the kinds of values returned, including EIP-7702 delegation, token standards, proxy implementation/admin, bytecode size, nonce, and ETH balance, so an agent knows what to expect.

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

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

Schema description coverage is 100%, and the single 'address' parameter is already documented as 'Any address on Arbitrum One'. The description reinforces the Arbitrum One scope but adds no syntax, formatting, or usage detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb, 'Identify', and clearly scopes it to an Arbitrum One address. It enumerates the exact distinctions and metadata it returns, including EOA vs contract, token standards, proxy details, bytecode size, nonce, and ETH balance, which makes it easy to distinguish from sibling tools such as wallet balances or token snapshots.

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 clearly establishes the usage context: inspect an Arbitrum One address for wallet/contract classification and contract metadata. It does not explicitly name when to prefer sibling tools like arbitrum_wallet_profile or arbitrum_token_snapshot, but the chain and purpose are sufficiently clear to guide selection.

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

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

With no annotations, the description carries the full burden. It does add genuinely useful context beyond the schema: a concrete price ($0.005 USDC on Base via x402) and the shape of the returned facts, which implies a cheap read-only operation. But it omits whether payment is required before the call, what happens on unapproved pairs, or what the response format looks like.

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 core capability is front-loaded in one dense sentence, followed by a short pricing note. Both sentences earn their place, though the function list inside the first sentence is slightly packed and could be split for readability.

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?

No output schema exists, and the description compensates by enumerating the four facts returned (allowance, unlimited flag, owner balance, spendable amount). For a three-address read tool this is nearly complete, missing only failure semantics for invalid or non-ERC-20 tokens.

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

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

Schema description coverage is 100%, so all three addresses are already documented with their roles. The description adds only conceptual framing (owner granted the approval, spender may transfer) and no format or edge-case detail beyond the schema. 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 the exact resource (ERC-20 allowance), the chain (Arbitrum One), and what the result conveys: spender allowance, unlimited-approval flag, owner balance, and currently spendable amount. The chain qualifier cleanly separates it from the eth_/base_/optimism_/polygon_ siblings of the same name.

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

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

Usage is implied by the described output fields (checking approvals, spotting infinite approvals, residual balance), but there is no explicit when-to-use or when-not-to-use guidance. It never routes the agent to a sibling such as arbitrum_token_snapshot or token_risk_check for related questions.

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

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

With no annotations, the description carries the full burden and does well: it discloses the paid-call model ($0.005 USDC on Base via x402), the price oracle used (Chainlink ETH/USD), and the units of each value. It omits freshness/caching behavior and what happens on payment failure, which keeps it from a 5.

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 tight sentence, front-loaded with the resource and chain, then the return payload, then the cost prerequisite. Every clause adds information an agent needs; 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?

There is no output schema and no annotations, so the description must cover both returns and the paid-access caveat — and it does, listing every returned field with units and the x402 payment requirement. An agent has enough to call it and to anticipate the charge.

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 zero parameters, so there is nothing to disambiguate; the baseline applies. The description correctly implies a parameter-free snapshot call by describing only the chain and returned values.

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 chain ('Current Arbitrum One gas conditions') and enumerates exactly what comes back: block number, base fee, gas price, priority fee, and transfer cost estimates. It clearly separates itself from base_gas_prices/eth_gas_prices by naming Arbitrum One, though it never explicitly routes an agent to those siblings.

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 — check gas before sending a transfer — but there is no explicit when-to-use or when-not statement, and no mention of alternatives for other chains. The $0.005 USDC payment note is a useful precondition, though it reads as a cost disclosure rather than guidance on when to prefer this tool.

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

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

With no annotations, the description carries the full burden and does well: it discloses the paid x402 requirement ('$0.02 USDC on Base'), the pool-coverage limitation (deepest WETH/USDC pools only), and the content of the response (trades, volume, net flow, top wallets). It stops short of stating per-call vs. session billing, rate limits, or error 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?

A single front-loaded sentence that opens with purpose and then enumerates returns and cost with no filler. The long clause listing output fields is justified because there is no output schema to carry that 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 and no annotations, the description supplies the return shape, the pool-coverage constraint, and the payment model — enough to call it correctly. Minor gaps: behavior when no qualifying trades exist and whether the $0.02 is charged per invocation or per result set.

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 token/minUsd/limit/minutes are already documented with ranges and defaults. The description adds only the qualitative framing ('last N minutes', 'largest trades', 'deepest pools'), which reinforces but does not extend the schema — 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+resource ('Whale and large-trade tracker for an ERC-20 on Arbitrum One') and scopes it to buy/sell activity in the token's deepest WETH/USDC Uniswap v3 pools over a look-back window. The chain qualifier plus 'whale/large-trade' framing separates it cleanly from the parallel eth_/base_/optimism_/polygon_ large_trades siblings and from snapshot/profile 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 gives useful context — only the deepest WETH/USDC pools are covered and only recent activity within N minutes — which implicitly frames what the tool is and isn't for. But it never names an alternative (e.g., arbitrum_token_snapshot for aggregate metrics) or states an explicit when-to-use / when-not-to-use condition, leaving 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?

With no annotations, the description carries the burden and does meaningful work: it discloses a mandatory $0.01 USDC payment on Base via x402 (an operational precondition an agent must know before calling) and warns that results are unvetted and spam-heavy. It stops short of stating freshness/latency or failure/payment-failure behavior, which keeps it from a 5.

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 core scope leads, followed by the returned-field inventory and then two short risk/cost caveats. It is dense but every clause carries information; the return-field list is a long run-on that could be trimmed, but not to the point of losing content.

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

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

Because there is no output schema, enumerating what comes back (both tokens with symbol/name/decimals, fee tier, v4 hooks, ETH/WETH/USDC pairing, quote liquidity where readable) is exactly the right compensation and the 'where readable' hedge sets expectations for nulls. Payment and spam caveats are covered; only freshness and behavior on unreadable liquidity remain thin.

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 limit and minutes are already documented with ranges, defaults and the 12,000-block cap. The description only echoes the 'last N minutes' window and 'newest first' ordering, adding no syntax or selection guidance beyond the schema — the baseline 3 for full 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+resource+scope: pools newly created on Arbitrum One within the last N minutes, sourced from Uniswap v4 and v3. The chain and DEX constraints let an agent separate it immediately from the sibling new_pools tools for Base, ETH, Optimism, Polygon and from arbitrum_large_trades or arbitrum_token_snapshot.

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 (discovery of freshly deployed pools) and the 'Unvetted: many new pools are spam' line signals the risk profile of acting on results. But there is no explicit statement of when to prefer this over arbitrum_large_trades, token_snapshot, or token_risk_check, and no guidance on narrowing the window versus widening it.

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

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

With no annotations, the description carries the full load and does disclose two important traits: a paid x402 call ($0.008 USDC on Base) and external fetching from IPFS/Arweave/HTTPS/data URIs, implying latency and possible upstream failures. It omits what happens when metadata resolution fails or is missing, keeping it short of a 5.

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

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

A single dense sentence, front-loaded with the purpose then the return contents then the cost. Every clause carries information, though the run-on structure with a long appositive slightly hurts scannability.

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 effectively documents the return shape (collection name, owner, token URI, decoded metadata JSON, image URL), which is what an agent needs. Missing only edge-case behavior (missing/broken metadata, ERC-1155 owner semantics) to reach a 5.

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

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

Schema coverage is 100% with both parameters fully documented (decimal tokenId pattern, contract address pattern). The description adds no parameter-level detail beyond 'on Arbitrum One', so baseline 3 is appropriate.

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

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

States a specific resource (ERC-721/ERC-1155 token metadata) scoped to a specific chain (Arbitrum One), and lists the exact fields returned. An agent can distinguish it from arbitrum_contract_info or arbitrum_token_snapshot by the NFT-specific output described.

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 ('NFT metadata'), but there is no explicit when-to-use or when-not-to-use guidance relative to siblings like arbitrum_contract_info or eth_nft_metadata (chain choice). The agent must infer selection from the chain scope alone.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the paid cost model ($0.01 USDC on Base via x402), the data provenance (deepest WETH or USDC pool on Uniswap v3), the exact risk-score semantics (0-100 with reasons), and its neutrality stance. It omits failure modes (non-token or non-contract address handling) and data freshness/caching, which keeps it below a 5.

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 but well-ordered sentence that front-loads purpose before enumerating outputs, plus a short closing line on neutrality and pricing. Every clause maps to a real attribute an agent would care about; the output enumeration is long but earns its place given there is no output 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?

No output schema exists, so the description must describe returns — it does, listing risk score, token metadata, ownership/renouncement, proxy detection, owner-only bytecode functions, and pricing/liquidity. Combined with the cost and data-source notes, an agent has what it needs to call and interpret the tool; only error/edge-case behavior is absent.

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

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

Schema coverage is 100% and the single parameter's schema description already says 'Token contract address on Arbitrum One', so the description adds no new meaning about the address argument. 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?

States a specific verb+resource ('rug check and due-diligence snapshot of an ERC-20 token on Arbitrum One') and enumerates the exact data returned. The chain qualifier cleanly separates it from the base/eth/optimism/polygon/solana token_snapshot siblings, and 'ERC-20 token' separates it from arbitrum_contract_info.

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 opening phrase ('Rug check and due-diligence') gives an unambiguous use case, and 'Facts only, no buy or sell opinion' frames the intent. It stops short of naming alternatives or exclusions (e.g., when to prefer token_risk_check or arbitrum_contract_info instead), so it does not reach 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?

With no annotations, the description carries the full burden and does disclose important behavioral context: the returned fields and the $0.005 USDC payment on Base via x402. It does not explicitly state read-only behavior, permission requirements, or failure modes, but the payment disclosure is materially useful.

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 the purpose and return fields, followed by the payment cost. 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?

There is no output schema, but the description compensates by enumerating the summary fields an agent will receive. It also discloses the payment requirement, though it omits explicit prerequisites or error-handling notes for a paid read 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?

Schema description coverage is 100% for the single hash parameter, including its format pattern and that it must be an Arbitrum One transaction hash. The description does not add syntax or meaning beyond the schema, so the high-coverage baseline of 3 applies.

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

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

The description states a specific verb and resource: a human-readable summary of an Arbitrum One transaction. It enumerates the exact fields returned, and the chain name distinguishes it from the many sibling *_transaction_summary 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?

Usage is implied by the chain-specific name and the required transaction hash, but the description never explicitly says when to use this instead of eth_transaction_summary, base_transaction_summary, or arbitrum_contract_info. The chain is clear, but alternatives are not named.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: data is read live from Arbitrum One, results are formatted with symbol and decimals, and the call costs $0.005 USDC on Base via x402 — a payment prerequisite an agent must know before calling. It stops short of describing failure modes for invalid token addresses or whether the ETH entry is always included.

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

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

A single dense sentence covering scope, chain, limit, formatting, and freshness, followed by the cost clause. The most decision-relevant information (what it returns, on which chain) is front-loaded 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 two-parameter read tool with no output schema and no annotations, the description covers return content (ETH plus token balances with symbol/decimals), chain, limits, and the x402 payment requirement. Only the shape of the returned data and error conditions are left thin, which is a minor gap at this complexity.

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 are already documented in the schema. The description only restates the 20-token cap and the fact that ETH is always included alongside the listed tokens, adding marginal meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description gives a specific verb+resource: reads native ETH balance plus up to 20 listed ERC-20 token balances on Arbitrum One, live. It implicitly distinguishes itself from the base/eth/optimism/polygon siblings by naming the chain, but it never contrasts with arbitrum_wallet_profile or arbitrum_token_snapshot, which are the nearest overlapping siblings.

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?

'Tokens you list' implies the caller must supply contract addresses and that unlisted tokens are not returned, which is usable context. There is no explicit statement of when to prefer this over arbitrum_wallet_profile or arbitrum_token_snapshot, and no prerequisites beyond the cost note.

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

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

With no annotations, the description carries the full burden, and it does disclose two things an agent cannot get elsewhere: the data source (Alchemy's transfer index) and that the call is paid — $0.01 USDC on Base via x402. It omits whether an unknown/non-existent address returns an empty profile or an error, and says nothing about index coverage limits or freshness.

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 core question is front-loaded and every clause names a concrete returned field; there is no filler. It is a long single run-on sentence built as a list, which is dense but readable and earns its length given there is no output 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?

With no output schema and no annotations, the description must substitute for return docs, and it does so by enumerating the profile contents across native, ERC-20 and NFT transfers plus USD-denominated large transfers. What is missing is edge-case behavior (invalid or unindexed address) and any indication of response size or pagination for the transfer lists.

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

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

Schema description coverage is 100% and the single address parameter carries a pattern and description, so the schema does all the work. The description adds nothing about the address parameter beyond reiterating 'Arbitrum One address', which is the baseline-3 case.

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 enumerated fields ('wallet age, first funder, contract or EOA, ETH balance and nonce, latest transfers, top counterparties') states a specific verb-equivalent (profile) and resource (Arbitrum One address) unambiguously. It implicitly separates itself from arbitrum_wallet_balances by covering age, funder and counterparties, but never names that sibling, so an agent must infer the boundary.

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-to-use guidance and no named alternative, even though several siblings (arbitrum_wallet_balances, arbitrum_transaction_summary, arbitrum_large_trades) overlap heavily on the data this tool returns. The agent can guess this is for investigative/due-diligence profiling, but nothing steers it away from cheaper, narrower siblings.

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 behavioral burden. It usefully discloses the $0.005 USDC x402 cost and the full set of returned fields, but never states that the operation is read-only/non-destructive, what happens for invalid or non-existent addresses, or any rate or permission constraints.

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

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

The purpose is front-loaded and the description is a single dense sentence with no filler. The long enumerated list of return fields is informative but borders on a laundry list; slightly tighter grouping of related items (e.g., token metadata vs proxy info) would improve scanability.

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

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

For a one-parameter lookup with no output schema and no annotations, the description does substantial work by naming all returned data and the cost. It is nearly complete, missing only error behavior and an explicit read-only assurance that annotations would normally provide.

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 exists and the schema already documents it fully ('Any address on Base', with a 0x-pattern), giving 100% schema coverage. The description adds no syntax or format guidance beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Identify what lives at a Base address') and enumerates the exact payload: EOA vs contract, token standards, name/symbol, proxy implementation and admin, bytecode size, nonce and ETH balance. This enumeration distinguishes it from siblings like base_wallet_balances, base_token_snapshot, and base_nft_metadata without needing to name them.

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

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

The purpose implies when to use it (classifying an address and retrieving contract metadata), but there is no explicit when-to-use, when-not-to-use, or routing to alternatives such as base_wallet_profile or base_transaction_summary. An agent can infer the use case but must decide on its own whether this or a sibling is appropriate.

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

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

With no annotations, the description carries the full burden and does disclose valuable context beyond the schema: the four result fields returned and the fact that the call costs $0.005 USDC on Base via x402. It does not explicitly state that it is a read-only/non-mutating call or describe failure modes, but the read-only nature is strongly implied by the query framing.

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 what is returned and followed by the payment cost. It is dense but every clause adds information; the only mild inefficiency is packing four return values into one long sentence.

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 appropriately enumerates the four result fields; it also discloses the x402 payment requirement, which an agent must know before calling. It stops short of explaining error behavior, token-decimal formatting, or how the unlimited-approval flag is determined, but for a three-address lookup tool it is largely complete.

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

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

Schema description coverage is 100%, and all three parameters are documented in the schema (token, owner, spender). The description does not add syntax, constraints, or edge-case guidance for those parameters, so it sits at the baseline.

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 the specific verb/resource (ERC-20 allowance), the chain (Base), and the exact facts returned: allowance amount, unlimited-approval flag, owner balance, and currently spendable amount. This distinguishes it from the parallel eth_/arbitrum_/optimism_/polygon_erc20_allowance siblings and from base_wallet_balances.

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

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

Usage is implied by the name and the described outputs, but there is no explicit guidance on when to choose this vs. base_token_snapshot, base_wallet_balances, or another chain's allowance tool. The paid x402 note hints that it should only be called when the allowance question is genuinely needed, but no exclusion or alternative is named.

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

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

With no annotations, the description carries the full behavioral burden; it helpfully discloses that the call costs $0.005 USDC via x402 and that ETH/USD conversion uses Chainlink. It does not explain payment/auth flow, rate limits, freshness guarantees, or failure behavior, so important operational context is still missing.

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

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

A single front-loaded sentence: it leads with the resource, then lists outputs, units, conversion source, and cost. Every clause earns its place, with no redundant or vague text.

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

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

Given no input parameters, no output schema, and no annotations, the description must convey the return contents and cost, and it does list the key fields, units, conversion source, and price. It is complete enough to call correctly, though it could clarify the payment flow or response shape.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to clarify. The baseline for zero-param tools 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 clear resource and chain ("Current Base gas conditions") and enumerates the returned values, so an agent can distinguish it from arbitrum_gas_prices, eth_gas_prices, and other chain-specific gas tools by name. It does not explicitly route the agent to or away from those siblings, but the chain scope 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 word "Current" implies this is for on-demand Base gas readings, and the cost disclosure signals it is a paid call. However, there is no explicit when-to-use/when-not guidance or comparison to sibling gas-price tools, leaving usage only implied.

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 does real work: it names the data sources (deepest WETH/USDC pools, Uniswap v3 or Aerodrome), the look-back semantics, and, crucially, the $0.02 USDC x402 payment requirement. It does not state failure behavior (e.g., token with no qualifying pools) or whether payment is taken when no trades exist.

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

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

Purpose and scope are front-loaded in the first clause, and the trailing sentence carries the non-obvious cost/payment fact. The main sentence is dense and packed with clauses, but each clause adds information rather than 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?

No output schema and no annotations, yet the description fully enumerates the returned fields (USD size, side, wallet, transaction, buy/sell volume, net flow, top wallets) and the payment model. Residual gaps are error/empty-result handling and the true window cap, the latter muddied by the schema's copy-pasted Arbitrum block note.

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 baseline is 3; the description adds real meaning by clarifying that only trades in the token's deepest WETH/USDC pools count and that the listing is composed of 'the largest trades', which explains how minUsd and limit interact with scope. It does not, however, address the window cap 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?

States a specific verb+resource ('Whale and large-trade tracker') scoped to an ERC-20 on Base, and enumerates what the result contains. The chain is embedded in the name and description, so it is trivially distinguishable from the arbitrum/eth/optimism/polygon variants without opening a 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?

Implied usage is clear (inspect whale activity on a Base token over a recent window), but there is no explicit when-not guidance and no named alternative such as base_token_snapshot or base_new_pools. The agent must infer the boundary from sibling names alone.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose two important traits: the data is unvetted/spam-prone and each call costs $0.01 USDC on Base via x402. It also pre-declares the shape of the returned fields. It omits failure behavior, rate limits, and what happens if the underlying log query is capped.

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: purpose/fields first, risk warning second, cost last – front-loaded and largely waste-free. The field enumeration is dense but serves selection, so 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?

There is no output schema, yet the description enumerates the return payload (token symbol/name/decimals, fee tier, v4 hooks, ETH/WETH/USDC pairing, quote liquidity), which is exactly what an agent needs to judge relevance. Combined with the cost and spam caveats, little is missing for a 2-param, all-optional read tool.

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

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

Schema coverage is 100% – both 'limit' and 'minutes' are fully documented with ranges and defaults in the schema, so baseline is 3. The description only restates 'last N minutes' and adds no format or edge-case guidance beyond the schema (the Arbitrum blocks-cap note oddly lives in the schema, not here).

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 (new trading pools), the chain (Base), the three venues (Uniswap v4/v3, Aerodrome) and the look-back window, plus the exact fields returned. An agent can distinguish this from eth_new_pools, arbitrum_new_pools, polygon_new_pools, etc., solely by chain and venue coverage.

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 resource (discover recently created pools) but there is no explicit when-to-use/when-not or named alternative among the many sibling tools. The one instructional signal is the 'Unvetted: many new pools are spam' warning, which tells the agent to treat output with caution rather than when to call it.

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

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

With no annotations, the description carries the full behavioral burden and does disclose important context: the tool costs $0.008 USDC on Base via x402 and returns decoded metadata plus a browser-loadable image URL. It does not spell out error behavior, read-only semantics, or payment mechanics, so it falls short of a full behavioral profile.

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

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

The description is compact and front-loaded: it states what the tool returns first, then adds the cost note. Both sentences carry useful information without 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?

There is no output schema, so the description appropriately lists the important return values and metadata sources. It also discloses cost, but could be more complete by describing payment requirements or error cases for missing metadata.

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 contract and tokenId parameters are already fully documented in the schema. The description does not add parameter-level syntax or constraints beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description names a specific resource (NFT metadata), chain (Base), and token standards (ERC-721/ERC-1155), and lists the returned fields. This clearly distinguishes it from sibling chain-specific NFT metadata tools such as eth_nft_metadata, arbitrum_nft_metadata, and polygon_nft_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?

It gives clear usage context: this is for NFT metadata on Base, for ERC-721 or ERC-1155 tokens. It does not explicitly name sibling alternatives or state when not to use it, but the chain-specific framing is sufficient for an agent to route correctly.

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

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

With no annotations, the description carries full burden and does well: it discloses the monetary cost ($0.005 USDC on Base via x402), which is critical behavioral context an agent cannot infer elsewhere. It stops short of describing the payment/settlement flow or the failure mode for unregistered names.

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: purpose and return values first, accepted input formats second, cost last. The parenthetical field list packs return-value detail without a separate sentence, and nothing is redundant.

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 with no output schema and no annotations, the description supplies the return fields explicitly and discloses cost. The one gap is error behavior for unregistered or malformed names, which matters for an agent deciding whether to retry.

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 the baseline is 3, but the description adds real value by spelling out the three accepted input forms ("jesse", "jesse.base", "jesse.base.eth"), which is more concrete than the schema's regex pattern and tells the agent normalization is handled.

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 (resolve) and resource (Basename / name.base.eth) and specifies the return payload: Base address plus profile records. It is clearly distinguishable from the sibling eth_resolve_ens by naming the Base chain and .base.eth suffix convention.

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 .base.eth name must become an address) but never explicitly names the alternative tool or states exclusions, e.g. what to do for ENS names (eth_resolve_ens). Usage is inferable from the naming convention 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 full burden and does so: it discloses the paid x402 flow and exact cost ($0.01 USDC on Base), the data provenance (deepest WETH or USDC pool on Uniswap v3 or Aerodrome), and that output is factual rather than advisory. These are exactly the operational facts an agent needs before committing to a paid call.

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 capability and output inventory, then closes with the decisive cost line. The middle clause is long and comma-dense but each item listed is return-relevant information, not filler.

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

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

No output schema and no annotations, yet the description enumerates the returned fields, states the price/liquidity source, and surfaces the payment cost and rail — everything needed to decide to call and to interpret the result. Only secondary gaps remain, such as behavior on a non-token address.

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

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

Schema coverage is 100% and the single parameter already documents the 0x-prefixed 40-hex contract address format. The description adds only the ERC-20-on-Base framing, which is implicit in the tool name and schema, so it neither fills a gap nor adds syntax 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?

States a specific verb and resource: a rug-check/due-diligence snapshot of an ERC-20 token on Base, and enumerates exactly what it returns (risk score, supply, owner, proxy detection, owner-only functions, price/liquidity/FDV). The Base prefix separates it from the arbitrum/eth/optimism/polygon/solana snapshot siblings, but it never distinguishes itself from token_risk_check, which sounds like an overlapping 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?

Usage is implied by 'rug check and due-diligence' and the 'facts only, no buy or sell opinion' scope framing, but there is no explicit when-to-use or when-to-avoid, and no pointer to token_risk_check or base_contract_info as the alternative for narrower questions.

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 a genuinely important behavioral trait: the $0.005 USDC x402 cost. It also tells the agent the shape of the return. It does not say what happens on an unknown hash or whether the call fails vs returns empty, which is the remaining gap.

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

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

Two sentences, front-loaded with purpose then cost. The field enumeration is dense but each item is informative; nothing is filler, though the list could be trimmed slightly without losing selection 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?

There is no output schema, so the description correctly compensates by enumerating the returned data (status, block/time, parties, value, gas, method, decoded ERC-20 transfers). Cost and chain are covered; error/not-found behavior is the only missing piece an agent 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?

Only one parameter and schema coverage is 100%, with the schema already documenting the hash including its 0x…64-hex pattern. The description adds the implicit "on Base" scoping but no further format or sourcing detail, so 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+resource ("Human-readable summary of a Base transaction") and enumerates the fields returned, so an agent knows exactly what it gets. The chain qualifier plus the field list cleanly separates it from eth_/arbitrum_/optimism_/polygon_transaction_summary siblings.

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 chain prefix and the required hash, but there is no explicit "use this when... / use X instead" guidance, no note that the hash must belong to Base, and no mention of the sibling per-chain summaries. The agent must infer routing from the tool name alone.

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

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

With no annotations, the description carries the full load and does well: it discloses that values are read live from Base, are formatted with each token's symbol and decimals, and — critically — that invoking it costs $0.005 USDC via x402. That payment disclosure is behavioral context an agent cannot get from the schema. It still omits error/edge behavior, e.g. invalid or non-ERC-20 token addresses, empty results, or whether pricing is per call.

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 with zero filler: what is returned, how it is formatted, where it is read from, and what it costs. Nothing needs trimming and the core payload leads the sentence.

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 read tool with no output schema, the description covers return shape (symbol and decimals formatting), data freshness (live), and cost. Remaining gap is failure/edge behavior for invalid token addresses or a mix of token types, which an agent would benefit from knowing.

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

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

Schema description coverage is 100% and both parameters are documented in-schema with regex patterns, so the baseline is 3. The description restates the 20-token cap and the output formatting, which adds mild value but no syntax or format detail beyond the schema.

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

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

States a specific verb and resource: reads native ETH balance plus up to 20 listed ERC-20 token balances on Base. The chain scoping ('Base wallet') implicitly separates it from eth_wallet_balances, arbitrum_wallet_balances and the other chain siblings, though it never names a sibling or explains the difference from base_wallet_profile.

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: an agent can infer it applies when it needs balance data on Base and has an address plus an optional token list. There is no explicit when-to-use/when-not-to-use guidance and no pointer to alternatives such as base_wallet_profile or base_token_snapshot.

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

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

With no annotations, the description carries the full burden and does disclose two things an agent cannot get from schema alone: the data source (Alchemy's transfer index) and the cost/auth requirement ($0.01 USDC on Base via x402), which is critical for avoiding surprise payments. It is clearly a read operation by nature, but it omits behavioral details such as how many 'latest' transfers or counterparties are returned, whether results are paginated, and how failures (invalid address, unpaid x402) behave.

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

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

A single dense sentence that front-loads the core question, then lists return contents, then ends with the cost/payment note — the ordering is sensible and nothing is padded. The long enumeration is justified because it is the only documentation of return contents in the absence of an output 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?

With no output schema and no annotations, the description is the sole source of return-value information, and it delivers a thorough inventory of what comes back plus the data source and payment cost. The remaining gaps are result cardinality/limits and error behavior, which matter less for a one-address read call than for a mutation.

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 exactly one parameter at 100% schema description coverage, including a regex pattern and the note 'Wallet or contract address on Base', so the schema does the work. The description adds no format, checksum, or cross-chain caveat beyond the schema, which is the expected baseline-3 case for fully documented params.

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 'Who is this Base address?' plus an explicit enumeration of returned fields (wallet age, first funder, EOA/contract, balance, nonce, transfers, counterparties, USD large transfers) states a specific verb+resource combination that an agent can match to a task. It implicitly distinguishes itself from base_wallet_balances and base_transaction_summary by covering far more than either, but it never names those siblings, so the differentiation is inferred rather than stated.

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: the tool is for profiling a single Base address, and the field list suggests it supersedes narrower sibling tools like base_wallet_balances. There is no explicit when-to-use, when-not-to-use, or named alternative, despite a crowded sibling set (wallet_balances, transaction_summary, contract_info, resolve_basename) where routing guidance would genuinely help.

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

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

With no annotations, the description carries the full burden and does well: it discloses weekend exclusion, observed-weekday shifting of weekend holidays, half-open interval semantics, that skipped holidays are returned, and — importantly — that invocation costs $0.005 USDC on Base via x402. It stops short of describing the exact response shape (e.g. field names for the count).

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

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

Two dense sentences with the core computation front-loaded and the payment note correctly placed last. Every clause carries information; the only mild redundancy is restating the interval boundary already present in 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 three-parameter, no-output-schema, no-annotation tool, this covers the essentials: what is counted, what is excluded, how boundaries behave, what extra data comes back, and the payment requirement. Only the precise return payload structure is left 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 description coverage is 100%, so the schema already documents all three parameters including the half-open 'to' semantics. The description's restatement of counting 'up to but not including the end date' reinforces that boundary but adds little beyond the schema's 'Day after the last day counted'.

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: counting business days between two dates for a Canadian province/territory, with the exclusion rules spelled out. An agent can tell this apart from canada_sales_tax, though it never explicitly contrasts itself with canada_statutory_holidays, which is the closest sibling given this tool also mentions returning skipped holidays.

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 computation described (use it when you need a working-day count for a province), but there is no explicit when-to-use/when-not, and no guidance on choosing between this and canada_statutory_holidays when the user wants holiday data rather than a count.

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

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

With no annotations, the description carries the full burden and does well: it discloses rounding to the cent, date-driven rate lookup with today as default, and — importantly for an agent — the x402 payment cost of $0.005 USDC on Base. It does not cover failure modes (invalid province code, out-of-range date), which keeps it from a 5.

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, each earning its place: what it returns, how dates drive rates, what it costs. The output shape is front-loaded before the caveats.

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 must describe the return — and it does, enumerating the tax components, per-rate and per-amount rounding, and the total. Amounts are stated in CAD. An agent has everything needed to call it and interpret the result.

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 baseline is 3. The description confirms province/amount/date usage and adds the 'pre-tax' and 'default today' framing, but adds no format or syntax details beyond what the enum and patterns already specify.

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: computes a Canadian sales tax breakdown (GST/HST/PST/RST/QST) for an amount in a province or territory. Nothing among the siblings (canada_business_days, canada_statutory_holidays, fx_ecb_convert) overlaps, and the description makes the distinction obvious without opening schemas.

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?

Clear context for when to reach for it: any CAD pre-tax amount needing province-level sales tax, with the date parameter used for historical rate changes (Nova Scotia 2025 HST cut). It stops short of explicit when-not guidance or naming an adjacent tool to use instead, but for a narrowly scoped calculator nothing is genuinely ambiguous.

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 add real context: it discloses that names are localized per province, that weekend holidays surface the observed weekday, and that invocation costs $0.01 USDC on Base via x402 — an important payment/auth trait an agent cannot infer from the schema. It stops short of explaining the observation/substitution rule precisely or what happens for invalid province/year combinations.

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 the resource and scope, followed by the cost disclosure. No redundant restatement of the tool name and nothing 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?

For a two-parameter lookup with no output schema, the description covers what comes back (holiday names, actual date, observed weekday) and the payment model, which is enough for correct invocation. The only remaining gap is the precise weekend-substitution rule, which affects interpreting the returned weekday.

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% (year pattern 2000-2100, province enum with a clear description), so the schema already documents both parameters fully. The description merely restates 'province or territory' and 'given year' without adding format or edge-case semantics, which is the baseline-3 case.

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

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

The description states the exact resource (statutory/general holidays) plus scope (one Canadian province or territory, one year) and the returned content (local holiday names, dates, observed weekday). It is immediately distinguishable from canada_business_days and canada_sales_tax by subject matter, though it never names those siblings or states the contrast 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 resource itself — call it when you need provincial holiday dates for a given year — and the x402 cost line gives a practical precondition (payment required). However there is no explicit when-to-use/when-not guidance and no pointer to the related canada_business_days or canada_sales_tax tools.

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

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

With no annotations, this description carries the full load and does it well: it discloses the 50-result cap and 'newest first' ordering, the returned fields, total counts, and the $0.005 USDC-on-Base x402 cost. It stops short of describing failure behavior (company not found, unsupported ATS) or whether results can be paged beyond 50.

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 purpose and source, then inputs, then return shape and cost. No filler, though the long ATS enumeration is dense and could be trimmed without losing meaning.

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?

No output schema and no annotations, yet the description covers inputs, providers, result cap, returned fields, total counts and pricing. An agent has everything needed to decide to call it and to interpret the response.

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

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

Schema description coverage is 100%, so the schema already documents company formats, comma-separated title alternatives, location matching, and the remote enum. The description restates those filters at a high level without adding syntax or edge-case semantics, so the 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 ('Open jobs at a company') plus the exact data source (the company's own ATS public job board) and enumerates the supported providers. No sibling tool covers job listings, and the description makes the scope unmistakable on its own.

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?

Explicit invocation guidance: 'Give a company name, website or job-board URL, with optional title, location and remote filters.' Context is clear, but there are no when-not-to-use notes or fallback guidance if the company's board can't be detected.

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 a critical non-obvious behavior — the tool is paid, costing $0.005 USDC on Base via x402 — which tells the agent a payment/auth flow is required before calling. It also implies the response contents, though it says nothing about failure modes, rate limits, or handling of non-existent addresses.

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 front-loaded sentences: the capability enumeration first, the payment condition second. The long list of returned attributes is dense but every item is load-bearing given there is no output schema, and no sentence is redundant.

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

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

For a one-parameter classification tool with no output schema and no annotations, the description supplies both the return-value inventory and the payment model — the two things an agent would otherwise have to discover by trial. Nothing essential 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?

Only one parameter, and schema description coverage is 100% ('Any address on Ethereum', with a 0x-prefixed 40-hex pattern). The description contributes no additional syntax or constraints beyond scope confirmation, so the 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?

Specific verb ('Identify what lives at') plus an explicit enumeration of what is returned: EOA vs contract, EIP-7702 delegation, token standard, name/symbol, proxy implementation/admin, bytecode size, nonce, balance. The chain-prefixed name plus 'Ethereum address' cleanly separates it from base_contract_info/arbitrum_contract_info and other siblings.

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 purpose implies when it applies (classifying an address or inspecting a contract), but there is no explicit when/when-not, no mention of alternatives such as eth_wallet_profile, eth_token_snapshot, or eth_wallet_balances, and no stated prerequisites. Usage is inferable rather than guided.

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, and it does add useful context: it lists the returned data points and discloses that the call costs $0.005 USDC on Base via x402. It does not describe side effects, error behavior, or rate limits beyond the per-call price, but the read-only nature is strongly implied by the query framing.

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 compact sentences with no wasted wording. The core purpose and return values are front-loaded, and the cost/payment detail is kept brief and separate.

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 usefully enumerates the key return values and notes the payment mechanism. For a simple three-parameter read query, this is largely complete, though it could be stronger with explicit read-only confirmation or error/ failure conditions.

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

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

Schema description coverage is 100%, and the schema already defines owner, token, and spender with address patterns. The description names the concepts but adds no format, constraints, or interpretation beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a precise verb+resource combination: 'ERC-20 allowance on Ethereum.' It also enumerates exactly what the tool returns (allowance, unlimited-approval flag, owner balance, spendable amount), and the 'on Ethereum' qualifier distinguishes it from sibling chain-specific allowance tools such as arbitrum_erc20_allowance and base_erc20_allowance.

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 scope 'ERC-20 allowance on Ethereum,' and the Ethereum qualifier helps route between sibling chain tools. However, there is no explicit guidance on when to use this versus related tools like eth_token_snapshot or eth_wallet_balances, and no stated exclusions or prerequisites beyond the payment note.

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

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

With no annotations, the description carries the full burden and does real work: it discloses the data source for the USD conversion (Chainlink ETH/USD) and, unusually, the payment requirement and price ($0.005 USDC on Base via x402) — critical pre-invocation context an agent cannot get from structured fields. It stops short of stating refresh cadence, caching, or whether the paid call fails loudly or returns partial data.

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

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

One front-loaded sentence: chain and subject first, then the returned fields, then the pricing/payment note. Every clause carries distinct information — no filler, no restatement of the tool name, and the expensive detail (cost of the call) is placed at the end where it is still noticed.

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 must describe the return payload — and it does, field by field, including the units for fees (gwei) and the dual-currency cost estimates. What keeps it from a 5 is the absence of any note on data freshness/latency and no cross-reference to the equivalent L2 gas tools for agents routing by chain.

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?

Zero parameters, so the baseline is 4; the description correctly implies a no-argument call and spends its words on outputs instead. There is nothing to mis-specify and no syntax an agent could get wrong.

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 (Ethereum gas conditions) and enumerates exactly what is reported: block number, base fee, gas price, priority fee, plus transfer cost estimates in ETH and USD. The chain is unambiguous from both the name and the text, which implicitly separates it from base_gas_prices/arbitrum_gas_prices, but it never names a sibling or says 'mainnet only' 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 inferable — 'Current' signals a live spot read, and the cost estimates hint at transfer-planning use — but there is no explicit when-to-use, no when-not-to-use, and no pointer to the L2 gas siblings for the same question on another chain. The agent must derive the selection rule from the tool name alone.

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

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

With no annotations to rely on, the description does disclose two non-obvious traits: it only covers the deepest WETH/USDC Uniswap v3 pools (a real coverage limit), and it costs $0.02 USDC on Base via x402 (a payment requirement). It does not say what happens when no qualifying pools or trades exist, or describe latency or rate 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?

It is one dense sentence that front-loads the resource and scope and ends with the cost signal, so no clause is wasted. The sentence is long, but each clause carries useful information.

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

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

For a four-parameter read tool with no output schema and no annotations, the description covers inputs, data sources, and the payment model well enough to invoke it correctly. The remaining gaps are edge-case behavior (empty results, unavailable pools), which are minor.

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

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

The schema documents all four parameters, so the baseline of 3 applies. The description reinforces how they interact ('last N minutes', 'largest trades', USD sizing), but adds no syntax or defaults beyond the schema.

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

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

The description names a specific resource ('whale and large-trade tracker'), scopes it to an ERC-20 on Ethereum, and enumerates the returned data (size, side, wallet, tx, volume, net flow, top wallets). This clearly distinguishes it from sibling tools like eth_token_snapshot, eth_transaction_summary, and the arbitrum_/base_/polygon_ large_trades variants.

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 look-back window and 'largest trades' framing imply the use case (recent whale activity on a token), but there is no explicit guidance on when to choose this over eth_token_snapshot or eth_transaction_summary, and no stated preconditions. The practical usage is inferable but not 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?

With no annotations, the description carries the full burden and does well: it discloses that results are unvetted/spam-prone, that liquidity is only returned 'where readable' (partial-data caveat), and that the call costs $0.01 USDC on Base via x402 — a payment requirement an agent must know before invoking. It omits failure behavior on payment and rate limits, so not a 5.

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 core purpose and keeps to roughly three sentences with no filler. The middle sentence is a long run-on field list, but every clause is informative rather than redundant.

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?

No output schema exists, and the description compensates by enumerating returned fields (tokens, symbols, decimals, fee tier, v4 hooks, quote-asset pairing, liquidity). Combined with the payment and spam disclaimers, an agent has enough to call it correctly; a response-shape description would have made 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 100%, and the schema documents both `limit` and `minutes` with ranges and defaults, so baseline is 3. The description's 'last N minutes' only echoes the schema and adds no new format or edge-case detail.

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 ('New trading pools created on Ethereum in the last N minutes'), enumerates the venues (Uniswap v4, v3) and the returned fields. The Ethereum + Uniswap scoping clearly separates it from the many sibling *_new_pools tools that cover other chains.

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 the chain and venue scoping; there is no explicit statement of when to choose this over arbitrum_new_pools, base_new_pools, etc., nor any prerequisite or exclusion guidance. The spam warning hints at a caveat but is not usage direction.

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

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

With no annotations, the description carries the full burden and does well: it discloses that metadata is fetched from IPFS, Arweave, HTTPS, or inline data URIs, that an image URL is produced, and that the call costs $0.008 USDC on Base via x402. It does not cover failure behavior, token-standard-specific limitations, or payment mechanics beyond price, which keeps it from a 5.

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?

It is a single dense sentence, front-loaded with the core resource and return contents, followed by the payment detail. Every clause adds useful information, though the sentence is long enough that it could be split for easier scanning.

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 and no annotations, the description adequately covers return values and the payment requirement, which are the critical pieces an agent needs. It omits error handling and edge cases such as missing metadata or ERC-1155 owner semantics, leaving a small 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 100%, so the schema already documents `contract` and `tokenId` fully. The description mentions ERC-721 vs ERC-1155 behavior for owner retrieval but adds little parameter-level semantics beyond what the schema provides, making 3 the correct baseline.

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 (ERC-721/ERC-1155 token metadata) and enumerates exactly what is returned: collection name, owner, token URI, decoded metadata JSON, and image URL. The chain qualifier 'on Ethereum' distinguishes it from the many sibling `*_nft_metadata` tools for other networks.

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

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

The context is clear: use this for NFT metadata on Ethereum, as opposed to contract info or token snapshots. However, it does not explicitly name alternatives or say when *not* to use it, leaving sibling selection mostly to the agent's inference.

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

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

With no annotations, the description carries real weight and does so: it discloses the resolver used (universal resolver) and the payment requirement ($0.005 USDC on Base via x402), which is critical for an agent to avoid unexpected failure. It omits behavior on unresolvable names and any partial-result semantics.

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 plus two short supporting sentences; the resolution direction and the returned record types lead, and the cost/auth note trails. No filler and nothing buried.

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?

Without an output schema or annotations, the description still tells the agent what comes back (address, avatar, description, url, Twitter, GitHub) and what it costs. Missing are failure/empty-result behavior and whether supplying both parameters is an error — meaningful for a paid, zero-required-param tool.

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

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

Schema coverage is 100%, so both parameters are documented at the structured level. The description adds value by framing them as alternatives — name for forward resolution, address for reverse lookup — and by enumerating the record types returned, which the schema does not convey.

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 (resolve) and resource (ENS name), covering both directions: forward resolution to address plus profile records, and reverse lookup from address to primary name. The `eth_` prefix and ENS specificity clearly separate it from `base_resolve_basename` among the siblings.

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 the two usage modes with example inputs ("vitalik.eth" vs "pass an address instead"), giving clear context for when each parameter applies. It stops short of naming the basename sibling as the alternative for Base names, leaving that distinction to the naming convention.

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 and does useful work: it discloses the exact paid-call cost ($0.01 USDC on Base via x402) and states 'Facts only, no buy or sell opinion.' It still does not explicitly state read-only/non-destructive behavior, rate limits, or error conditions, but it adds substantial context beyond the schema.

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 with the core purpose and contains no filler; every clause about outputs, no-opinion stance, and cost is relevant. However, the long output-field enumeration makes it dense and slightly less scannable than it could be.

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

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

Given that there is no output schema and no annotations, the description does a thorough job enumerating the returned risk score, token metadata, ownership details, proxy detection, bytecode findings, and market data. It also discloses payment cost and source pools, leaving little essential context missing for a one-parameter snapshot 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?

There is only one parameter, and the input schema already fully documents it with a pattern and description ('Token contract address on Ethereum'). The description restates the Ethereum/ERC-20 context but adds no further syntax or semantic detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific resource and scope: a due-diligence snapshot of an ERC-20 token on Ethereum, with a detailed enumeration of returned fields. It does not explicitly distinguish itself from nearby siblings like token_risk_check or eth_contract_info, so it falls short of full sibling differentiation.

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

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

The phrases 'Rug check and due-diligence snapshot' imply the intended use case, but the description gives no explicit when-to-use guidance, exclusions, or alternatives among the many sibling tools. An agent can infer the context, but routing decisions remain underspecified.

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 exist, so the description carries the full behavioral burden. It does the two highest-value things: it discloses a real cost ('$0.005 USDC on Base via x402') — critical for an agent deciding whether to call — and it enumerates the returned content, which implicitly establishes this is a read-only lookup. Gaps remain on failure behavior (nonexistent hash, unconfirmed/pending tx) and 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?

Two sentences, zero padding. The payload enumeration is front-loaded and the payment caveat is placed last where it reads as a footnote, which is the right ordering.

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?

Since no output schema exists, the field enumeration in the description is doing necessary work and covers the return value well. The only real omissions are error/not-found semantics and whether transfers covers only ERC-20 (it says so) or also native/NFT movement — minor against an otherwise complete definition.

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?

Single parameter with 100% schema description coverage, including a pattern constraint and a description ('Transaction hash on Ethereum'), so the schema does all the work. Baseline 4 for a one-param tool; the description adds nothing beyond it, but nothing is missing either.

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

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

Specific verb+resource ('Human-readable summary of a Ethereum transaction') followed by an enumeration of exactly what the summary contains (status, block/time, sender/recipient, value, gas, method selector, decoded ERC-20 transfers). The 'Ethereum' qualifier plus the eth_ prefix distinguish it from the arbitrum_/base_/optimism_/polygon_transaction_summary siblings.

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 rather than stated: the required hash parameter and the 'transaction summary' framing make the lookup use case obvious, but the description never says when to prefer this over eth_wallet_profile or eth_token_snapshot, nor does it explicitly say 'mainnet only — use base_transaction_summary for Base'.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that reads are live from chain, that the call is a paid x402 endpoint costing $0.005 USDC on Base, and that output is decorated with symbol and decimals. It omits failure behavior (unverified tokens, payment rejection) and rate limits, so it falls short of a 5.

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

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

A single dense sentence that front-loads the return value and ends with the cost caveat, with no filler. Slightly packed — the payment detail and formatting detail compete for one clause — but nothing is wasted.

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 tool with no output schema, the description conveys what comes back (native balance plus per-token balances with symbol/decimals) and the commercial precondition (x402 payment). What's missing is error handling for tokens lacking metadata and any hint of response shape beyond formatting.

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

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

Schema coverage is 100% and both parameters already document address format and the comma-separated, max-20 token contract list. The description's 'up to 20 ERC-20 tokens you list' restates the schema rather than adding new syntax, ordering, or edge-case guidance, so 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+resource: returns native ETH balance plus up to 20 ERC-20 token balances for a wallet, read live from Ethereum, with symbol/decimals formatting. The chain qualifier 'on Ethereum' clearly distinguishes it from the arbitrum_/base_/polygon_/optimism_wallet_balances siblings.

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 implies usage (check a wallet's ETH and listed ERC-20 holdings) and notes the x402 cost, but never states when to prefer eth_wallet_profile or eth_token_snapshot, nor any prerequisite such as holding USDC on Base to pay. The alternative routing is left to inference.

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

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

With no annotations, the description carries the full burden and does well by disclosing the data source (Alchemy's transfer index) and the payment requirement ($0.01 USDC on Base via x402). It does not explicitly state read-only semantics, rate limits, or behavior when certain data points are unavailable, but the payment and source disclosures are meaningful operational context.

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

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

The description is front-loaded with the core question and then efficiently enumerates the returned profile dimensions. The cost sentence is separated and useful. The first sentence is long but dense with relevant information rather than 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 tool with no output schema, the description does a strong job explaining what information the profile includes, where it comes from, and what it costs. It stops short of specifying output format, time windows for 'latest' or 'recent', or null-handling, but it gives an agent enough to decide whether to invoke it.

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 only one parameter, and the input schema fully documents it with a description and pattern. The description reinforces that the address is the subject of the profile but adds no syntax or constraints beyond the schema, so the baseline of 3 applies.

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

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

The description clearly frames the tool as a comprehensive Ethereum wallet profiler, listing the specific data returned: wallet age, first funder, contract/EOA status, balance, nonce, transfers, counterparties, and large USD transfers. It is distinguishable from siblings like eth_wallet_balances, though it does not explicitly name or contrast those alternatives.

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

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

The enumerated outputs imply when the tool is useful: when an agent needs a holistic address profile rather than a single data slice. However, it never explicitly says when to use this versus eth_wallet_balances, eth_transaction_summary, eth_contract_info, or other siblings, and it provides no exclusions or prerequisites beyond the cost note.

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 reasonably well: it discloses the paid nature ($0.005 USDC on Base via x402), the data source, and what is returned (rate used, result, rate date). It stops short of stating rounding behavior or what happens on non-publishing days.

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 tight sentences: the operation and its scope come first, the payment cost last. No filler and nothing redundant with 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?

There is no output schema, but the description enumerates the return payload, which covers the main gap. Minor omissions remain around rate availability on non-business days and whether the conversion is EUR-crossed, but nothing essential for correct invocation 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 coverage is 100%, so every parameter is already documented in the schema. The description only echoes the optional-date behavior and says nothing extra about cross-rate mechanics or amount precision, so the 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 ('Convert an amount between two currencies') plus the exact rate source (ECB daily reference rate), so the agent knows precisely what it gets. It does not mention the sibling fx_ecb_rates, so the distinction between converting and merely listing rates must be inferred.

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?

'latest or for a past date' implies when the optional date parameter should be supplied, which is useful context. However, there is no explicit guidance on when to pick this over fx_ecb_rates, nor any note about weekends/holidays when ECB publishes no rate.

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

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

With no annotations, the description carries the full burden and does well: it discloses update cadence (once per working day), that the response states the effective day, the ~30 currency universe, and a paid x402 cost of $0.005 USDC on Base. Missing only error/failure behavior and any rate-limit or caching notes.

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 resource and scope, then cadence, then payment cost. Nothing is redundant.

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-required-param read tool with no output schema, the description covers cadence, effective-date reporting, currency coverage, and payment cost — everything needed to invoke it. A brief note on returned structure or the convert alternative 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 100%, so all three parameters are already documented, giving a baseline of 3. The description reinforces base-currency and date semantics but adds no format or interaction detail beyond the schema.

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

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

States a specific resource (European Central Bank daily reference rates) and scope (about 30 major currencies, any base, latest or historical). An agent can tell this returns rate data rather than computing a conversion, but it never names fx_ecb_convert, so the sibling boundary must be inferred.

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?

"Latest or for a past date" gives implicit selection guidance, but there is no explicit when-to-use statement and no routing to fx_ecb_convert for actual currency conversion. The usage context is inferable 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 behavioral burden and does well: it discloses the identification behavior, EIP-7702 delegation handling, proxy/admin detection, bytecode size, nonce, ETH balance, and the x402 payment cost. It does not explicitly state read-only/no side effects or rate limits, but the 'Identify' framing and cost disclosure make the read operation clear.

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 with the core purpose and then enumerates useful return details. It is dense but mostly earns its length; the long capability list is relevant, though slightly list-heavy.

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

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

For a one-parameter read tool with no output schema, the description thoroughly enumerates the important return values: wallet vs contract, token standards, name/symbol, proxy implementation/admin, smart-wallet proxies, bytecode size, nonce, ETH balance, and cost. That is enough for an agent to know what to expect from the 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?

The input schema has 100% description coverage for the single address parameter, so the schema already explains the expected input. The description adds only the OP Mainnet context and does not provide extra syntax or format details beyond the schema.

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

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

The description uses a specific verb, 'Identify', and clearly names the resource: what lives at an OP Mainnet address. It explicitly distinguishes wallet/EOA, EIP-7702 delegation, contracts, token standards, proxy details, and metadata, so an agent can understand the tool's scope 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?

The description implies usage by listing what the tool returns and naming the chain, but it does not explicitly say when to use this instead of siblings like optimism_wallet_profile, optimism_wallet_balances, or optimism_token_snapshot. The $0.005 cost is useful context but not a usage rule.

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 at all, the description does real work: it discloses that the call is a read, that it returns an 'effectively unlimited' determination and a balance in addition to the raw allowance, and it flags the payment model ($0.005 USDC on Base via x402), which is critical operational context an agent must know before invoking. It stops short of describing failure behavior for non-contract tokens or malformed addresses.

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: the return semantics are front-loaded and the cost note is short and actionable. The first sentence is a dense four-item list, but every item 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 3-parameter read with no output schema, the description supplies the return shape and the payment requirement, which is what an agent needs to decide and call. Minor gaps: it does not explain how amounts are formatted (raw base units vs decimals) or how the 'spendable right now' figure is derived.

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

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

Schema description coverage is 100% and all three parameters already carry descriptions ('Address that granted the approval', 'ERC-20 contract on OP Mainnet', 'Address allowed to spend'). The description adds no syntax, format, or role nuance beyond that, so the 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 the specific resource (ERC-20 allowance), the exact chain (OP Mainnet), and enumerates the returned facts: allowance amount, unlimited-approval flag, owner balance, and currently spendable amount. The chain qualifier cleanly separates it from eth_/base_/arbitrum_/polygon_erc20_allowance siblings.

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 chain scoping implicitly tells the agent to pick this variant for OP Mainnet rather than another chain's allowance tool, but there is no explicit when-to-use/when-not-to-use statement, no mention of prerequisites (e.g. token must be a contract), and no named alternative for other chains.

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

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

With no annotations, the description carries the full burden and does disclose key behavioral context: it costs $0.005 USDC on Base via x402 and uses Chainlink ETH/USD for USD estimates. It implies a read-only data lookup but does not describe payment mechanics, caching, or rate limits in 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 dense sentence with no filler, front-loading the resource and then listing returned data and pricing. Every clause contributes information needed to decide and call the 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?

For a no-parameter, no-output-schema tool, the description provides enough: it specifies the returned fields, units for fees, ETH and USD cost estimates, the Chainlink price source, and the payment cost/mechanism. Nothing essential for correct invocation appears to be 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?

The tool has zero parameters and the schema is empty, so there are no parameter semantics to explain. The baseline for a no-parameter tool is 4, and nothing in the description contradicts the absence of inputs.

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 the specific resource and chain: 'Current OP Mainnet gas conditions', and enumerates exactly what is returned (block number, base fee, gas price, priority fee, transfer cost estimates). This clearly distinguishes it from sibling gas-price tools for Ethereum, Arbitrum, Base, and Polygon.

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 chain-specific wording makes the intended context clear: use this for OP Mainnet gas conditions rather than another chain's gas tool. It does not explicitly name alternatives or exclusions, but the scope is unambiguous for an agent selecting among sibling gas-price tools.

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

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

With no annotations, the description carries the burden and delivers the two things an agent most needs: this is a paid call ($0.02 USDC on Base via x402) and it only covers the token's deepest WETH/USDC pools, so thin-liquidity tokens may yield little. It also enumerates what the payload contains (size, side, wallet, tx, volume, net flow, top wallets). It stops short of rate limits or empty-result 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?

Front-loaded with the capability and return content in one dense sentence, then the payment requirement as a second sentence. No filler, though the primary sentence is long and could be split for scannability.

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?

No output schema exists, so the description must describe results — and it does, listing every notable field (USD size, side, wallet, transaction, buy/sell volume, net flow, top wallets) alongside the payment model and pool-scope limitation. Nothing an agent needs to decide to call it correctly 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 coverage is 100%, so the baseline is 3; the description only restates that the window is 'last N minutes' and that only the largest trades are returned, without adding format or boundary detail (the minUsd/limit semantics live in the schema). Note the schema's own minutes description wrongly references Arbitrum ('capped at 12,000 blocks, about 50 minutes on Arbitrum') on an OP Mainnet tool, which the description does not correct.

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 (whale/large-trade tracker for an ERC-20 on OP Mainnet) plus the exact scope: buys and sells in the last N minutes on the token's deepest WETH/USDC pools via Uniswap v3 or Velodrome. An agent can distinguish it from optimism_token_snapshot or optimism_transaction_summary without opening any 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?

Usage is implied by the time-window and size framing (use it to see big trades in a lookback window), but there is no explicit when-to-use vs when-not, no mention of the sibling aggregate tools like optimism_token_snapshot, and no guidance for tokens without deep WETH/USDC pools.

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

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

With no annotations, the description carries the full burden and does well: it discloses the $0.01 USDC cost on Base via x402 payment, that results are unvetted and often spam, and that liquidity is only reported 'where readable' (i.e., partial data). It does not mention rate limits or failure modes, which keeps it from a 5.

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 what the tool returns, followed by the spam caveat and the price. Dense but every clause (DEX list, field list, spam warning, cost) contributes information an agent needs.

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 the description compensates by enumerating the returned fields, so an agent knows the shape of the response. The payment requirement and data-quality caveat are also covered; only pagination/ordering detail (though 'newest first' exists in schema) and rate limits are absent.

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 the schema already documents both limit and minutes with ranges and defaults. The description only restates 'last N minutes' at a high level and adds no range or format detail beyond the schema, so the 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 names a specific verb+resource (new trading pools created on OP Mainnet), the look-back window, the three DEXes covered, and the exact fields returned (both tokens with symbol/name/decimals, fee tier, v4 hooks, quote asset, liquidity). It is clearly distinguishable from sibling tools like base_new_pools or arbitrum_new_pools by chain and DEX set.

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 clear: this is a fresh-pool discovery tool for OP Mainnet, and the 'Unvetted: many new pools are spam' note warns the agent about result quality. It does not explicitly state when to prefer this over token_risk_check or the chain-specific siblings, but the chain scoping makes the alternative implicit.

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

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

With no annotations, the description carries the full burden and does well: it discloses that metadata is fetched from external storage (IPFS, Arweave, HTTPS, inline data URI), that the owner field only applies to ERC-721 (ERC-1155 has no owner), and that the call costs $0.008 USDC on Base via x402 — a prerequisite an agent must satisfy before invoking. It stops short of describing failure modes for unresolvable URIs or malformed metadata.

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 enumerating return fields followed by a short payment sentence — front-loaded and free of filler. The enumeration is long but every item is a distinct return field an agent would otherwise have to discover by calling.

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 compensates by listing the returned fields and their shapes (owner only for ERC-721, image as browser-loadable URL). Combined with the payment prerequisite, an agent has enough to decide and call. Minor gap: no statement of behavior when a token does not exist or metadata is unreachable.

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

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

Schema coverage is 100% and both parameters are described with patterns, so the schema does the heavy lifting. The description adds only the constraint that `contract` must be an OP Mainnet collection; it says nothing new about tokenId formatting or edge cases.

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 (fetch ERC-721/ERC-1155 token metadata) and enumerates exactly what comes back: collection name, current owner, token URI, decoded metadata JSON, and image URL. The chain scope ('on OP Mainnet') cleanly separates it from the eth_/base_/arbitrum_/polygon_nft_metadata siblings without needing to name them.

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

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

The chain qualifier implicitly tells an agent to pick this tool only for OP Mainnet tokens, which is the primary routing decision among the five nft_metadata siblings. However, there is no explicit when-to-use/when-not guidance, no mention of what to do for unsupported chains, and no note that this is a paid call versus the free-looking siblings.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the $0.01 USDC x402 cost, indicates the output is factual rather than advisory, and implies a read-only snapshot. It does not explicitly state read-only status or rate-limit behavior, but the paid-read nature is clear.

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 first sentence front-loads the core purpose and return contents; the two short follow-up sentences add useful caveats about opinion-free output and cost. The long enumerated sentence is dense but each listed field helps an agent understand what the snapshot provides.

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?

Because there is no output schema, the description must explain return values, and it comprehensively lists risk score, token metadata, ownership/renouncement status, proxy detection, bytecode findings, and market data. For a one-parameter paid snapshot tool, an agent has enough context to invoke 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?

There is only one parameter and schema description coverage is 100%, so the schema already documents that it expects a token contract address on OP Mainnet. The description reinforces the ERC-20/OP Mainnet scope but adds no meaningful syntax or constraint beyond the schema.

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

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

The description gives a specific verb/resource: a rug-check and due-diligence snapshot of an ERC-20 token on OP Mainnet. It lists the exact dimensions returned, making it clearly distinct from generic siblings such as optimism_contract_info or wallet-oriented 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 use case is implied by 'Rug check and due-diligence snapshot,' and the description clarifies that it returns facts only, with no buy/sell opinion. However, it does not explicitly say when to use this instead of related siblings like token_risk_check or optimism_contract_info.

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 does disclose the meaningful behavioral trait that the call costs $0.005 USDC on Base via x402, which an agent needs before invoking. It does not cover read-only guarantees, latency, caching, or failure modes, so it 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?

Two sentences: the first front-loads the return contents, the second carries the payment constraint. No filler, no repetition of the name or title.

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 listing the returned fields, and it discloses the x402 cost. For a one-parameter lookup this is nearly complete; only error/empty behavior and the exact response shape remain unstated.

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 a single parameter with 100% schema description coverage, including a regex pattern, so the schema fully specifies its meaning and format. The description adds nothing beyond it, which is the baseline expectation for a fully documented single-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 resource (an OP Mainnet transaction) and enumerates exactly what the summary contains: status, block/time, sender/recipient, ETH value, gas, method selector, and decoded ERC-20 transfers. The network prefix in the name plus the explicit 'OP Mainnet' in the text separates it from the eth_/base_/arbitrum_/polygon_ variants, though it never states that distinction 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?

There is no guidance on when to choose this over a sibling like optimism_wallet_balances or optimism_token_snapshot, nor any mention of prerequisites or error conditions (e.g. what happens for an unknown hash). Usage is only implied by the tool name and the input.

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

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

With no annotations present, the description carries the load and does meaningful work: it discloses the payment cost ($0.005 USDC on Base via x402), that data is read live from OP Mainnet, and that only explicitly listed tokens are returned (no auto-discovery). It stops short of covering failure modes such as invalid or non-ERC-20 token addresses.

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

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

A single dense sentence with the core capability front-loaded and the cost/chain constraints trailing. Every clause contributes something an agent could not infer from the schema alone.

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

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

There is no output schema, so the description correctly explains the return shape (balances formatted with symbol and decimals) and the payment requirement. That covers what an agent needs to call it, though error handling for malformed or non-ERC-20 token entries is left unstated.

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 are already documented in the schema. The description restates the 20-token cap and the ERC-20 nature of the listed tokens but adds no syntax, ordering, or edge-case detail beyond what the schema provides, so 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 names a specific resource (native ETH plus up to 20 listed ERC-20 balances) on a specific chain (OP Mainnet), so the verb and scope are unambiguous. It does not explicitly separate itself from the near-identical sibling optimism_wallet_profile or optimism_token_snapshot, which keeps it from 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 phrasing 'tokens you list' and 'read live from OP Mainnet', which suggests a spot-check read. There is no explicit when-to-use guidance, no statement of when to prefer optimism_wallet_profile or optimism_token_snapshot, and no preconditions beyond the address.

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

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

With no annotations, the description carries the burden and does disclose two non-obvious traits: the data source (Alchemy's transfer index) and the cost ($0.01 USDC on Base via x402), which materially affects agent behavior. It does not cover caching, rate limits, or failure modes for unknown/inactive addresses, keeping it short of a 5.

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, front-loaded sentence that leads with the core question and then lists returns, plus a separate cost/source sentence. The return-value enumeration is long but each item is informative; minor density cost from listing every asset type (ETH, WETH, USDC, USDT, NFTs).

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 and no annotations, the description must explain what comes back — and it enumerates return contents thoroughly, plus cost and data source. Missing only edge-case behavior (address with no history, invalid checksum, pagination/limits on 'latest transfers') to reach a 5.

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

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

Schema description coverage is 100% and the single `address` param is documented with a pattern, so the schema does the heavy lifting. The description adds only the network scoping ("OP Mainnet address"), matching the baseline 3 for full schema coverage.

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

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

Opens with a specific question-prefixed verb ("Who is this OP Mainnet address?") and enumerates the exact resource contents: wallet age, first funder, contract vs EOA, ETH balance, nonce, transfers, counterparties, large USD transfers. That enumeration clearly separates it from siblings like optimism_wallet_balances (balances only) and optimism_transaction_summary (single-tx detail).

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 via the question framing — an agent can infer "use this to profile/due-diligence an address," but there is no explicit when-to-use, when-not-to-use, or named alternative among the many optimism_* siblings. No exclusions or prerequisites (e.g., address must be on OP Mainnet) are stated beyond the schema.

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

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

With no annotations, the description carries the full burden and does well: it discloses the paid x402 model with a precise price ($0.005 USDC on Base) and enumerates the returned fields, which is critical since there is no output schema. It is implicitly a read-only lookup. Minor gaps remain — no statement about behavior for a non-existent/EOA address (partial result vs error) or any rate/response-time notes.

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 purpose in the first clause, followed by a dense but scannable enumeration of returned data and a separate cost sentence. No filler, though the return-field list is long; it earns its length because no output schema exists to carry that information.

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

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

For a one-parameter read tool with no annotations and no output schema, the description covers purpose, chain scope, return surface and payment cost — everything needed to decide to call it and interpret results. The remaining gap is failure semantics for invalid or non-contract addresses and any note on output format beyond field names.

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

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

Schema description coverage is 100% and the single address parameter carries its own description and a ^0x[0-9a-fA-F]{40}$ pattern, so the schema already does the work. The description adds only that the address must be on Polygon PoS, which is marginal beyond the schema. Baseline 3 applies for a fully documented single parameter.

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

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

States a specific verb ('Identify what lives at') plus the exact resource scope (a Polygon PoS address) and enumerates the concrete outputs: EOA vs contract, EIP-7702 delegation, ERC-20/721/1155, name/symbol, proxy implementation and admin, bytecode size, nonce and POL balance. The chain qualifier cleanly separates it from eth_contract_info, base_contract_info and the other *_contract_info siblings, and the descriptive scope separates it from polygon_wallet_profile / polygon_token_snapshot.

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 enumeration of outputs strongly implies when to reach for it (address classification and token/proxy inspection on Polygon), but no explicit when-to-use or when-not-to-use statement exists and no sibling is named as an alternative. An agent must infer that polygon_wallet_profile is the choice for transactional history and polygon_token_snapshot for token-market data rather than learn it 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?

With no annotations, the description must carry the behavioral load, and it discloses a genuinely non-obvious trait: the call costs $0.005 USDC on Base via x402. It also makes the response content predictable. It stops short of covering failure modes or latency, but the paid-call disclosure is the piece an agent most needs 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, front-loaded with the purpose and returned fields, with the pricing note second. No filler, no repetition of the tool name, and nothing that could be cut without losing 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?

No output schema exists, so the description appropriately enumerates the four returned values, and all three required params are covered by the schema. What's missing is minor: the actual response shape/field names and behavior on invalid or unapproved pairs.

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

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

Schema description coverage is 100% and all three parameters are documented (owner grants, token is the ERC-20 contract, spender is allowed to spend). The description's 'a spender may transfer from an owner' restates those roles in allowance terms but adds no format or constraint detail beyond the schema, so the 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?

Names the exact resource (ERC-20 allowance), the chain (Polygon PoS), and enumerates what is returned: allowance amount, unlimited-approval flag, owner balance, and current spendable amount. The chain qualifier cleanly separates it from eth_erc20_allowance, base_erc20_allowance and the other chain-prefixed siblings without needing 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?

Usage is only implied: phrases like 'whether the approval is effectively unlimited' hint at a token-approval security review, but there is no explicit when-to-use, no exclusion, and no pointer to alternatives such as polygon_wallet_balances or polygon_token_snapshot. An agent must infer whether to call this or a broader balance/snapshot tool.

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

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

With no annotations, the description carries the full burden and does disclose the material behavioral facts: this is a read-only snapshot of gas conditions, the USD conversion relies on a Chainlink POL/USD feed, and the call requires payment of $0.005 USDC on Base via x402. It stops short of stating freshness/caching behavior or whether the paid amount is charged per call, which would matter for an agent deciding how often to poll.

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 tight sentences: the payload contents first, then the payment terms. Every clause ('in gwei', 'native transfer and an ERC-20 transfer', 'Chainlink POL/USD') adds information an agent would otherwise have to guess, and the cost disclosure is placed where it will be seen rather than buried.

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 and no parameters, the description fully specifies the return payload down to units and the oracle used for the USD leg, and it surfaces the payment requirement that would otherwise be a surprise at call time. Nothing an agent needs to call it correctly 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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to clarify on the input side. All useful semantics are packed into the return-value description instead.

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 chain ('Current Polygon PoS gas conditions') and enumerates exactly what is returned: block number, base fee, gas price, priority fee in gwei, and transfer costs in POL/USD. The chain specificity plus the sibling naming convention (eth_gas_prices, base_gas_prices, arbitrum_gas_prices) makes it unambiguous which tool to pick for Polygon.

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 Polygon scope implies when to use it relative to the other *_gas_prices siblings, and the explicit '$0.005 USDC on Base via x402' note tells the agent this call has a real cost — important context for deciding whether to invoke it. However, it never states exclusions or names an alternative, and doesn't say whether repeated polling is advisable given the per-call charge.

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 and does well: it discloses the $0.02 USDC x402 payment, the Polygon PoS scope, the Uniswap v3 WPOL/USDC pool source, and the returned fields such as USD size, side, wallet, volume, and net flow. It stops short of covering rate limits, error behavior, or empty-result handling.

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 dense but front-loaded sentence that leads with the core purpose and then adds scope, data fields, and cost. It contains no filler, though the long colon-and-semicolon structure is somewhat run-on.

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 data-retrieval tool with no output schema and no annotations, the description is largely complete: it explains the chain, data source, look-back window, returned metrics, and payment requirement. Minor gaps remain around edge cases and rate/error behavior, but an agent has enough to 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 description coverage is 100%, so the parameter schema already defines token, limit, minUsd, and minutes with ranges and defaults. The description adds only loose alignment via phrases like 'last N minutes' and 'USD size', without meaningfully extending parameter semantics beyond the schema.

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

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

States a specific verb/resource combination: tracks whale and large trades for an ERC-20 on Polygon PoS. It narrows the scope to the token's deepest WPOL/USDC Uniswap v3 pools and enumerates the returned data, so it is clearly distinguishable from chain-specific siblings such as arbitrum_large_trades or eth_large_trades.

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

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

The description gives a clear usage context: it is for whale/large-trade tracking on Polygon PoS. It does not explicitly state when not to use it or name an alternative sibling, but the chain and dataset focus make the intended use obvious.

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 zero annotations the description carries the full burden and does well: it discloses the paid access model ('Costs $0.01 USDC on Base via x402'), flags the data as unvetted/spam-prone, and hedges output coverage with 'quote liquidity where readable'. It stops short of describing failure modes or what happens if payment is unavailable.

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?

Highly front-loaded: chain, scope, venues and output fields come first, then the spam caveat and the price. The opening sentence is long and list-heavy, but every clause carries information an agent needs.

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-optional-param, annotation-free tool with no output schema, the description covers inputs, return shape, data quality risk and the x402 payment requirement. The remaining gap is operational: it doesn't say what the agent must have pre-arranged to satisfy the $0.01 USDC charge.

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

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

Schema description coverage is 100% and both parameters (limit, minutes) are fully documented with ranges and defaults in the schema. The description only echoes 'last N minutes' without adding format or interaction details, so the 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 resource and scope: new trading pools on Polygon PoS created in the last N minutes, restricted to Uniswap v4 and v3. It also enumerates the returned fields (token symbol/name/decimals, fee tier, v4 hooks, POL/WPOL/USDC pairing, quote liquidity), which clearly separates it from polygon_token_snapshot, polygon_large_trades and the *_new_pools siblings on other chains.

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 described output (fresh pool discovery) and the warning that 'many new pools are spam' sets expectations, but no alternative is named (e.g. polygon_token_snapshot or token_risk_check for vetting) and no explicit when-to-use/when-not condition is given.

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 and does well: it discloses the paid-x402 model, the exact price ($0.008 USDC on Base), and the resolution strategy across IPFS, Arweave, HTTPS and inline data URIs, plus that the image URL is browser-loadable. Gaps remain around failure behavior for burned/nonexistent tokens and whether metadata fetch failures are surfaced as errors or nulls.

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 resource and an enumerated payload, with the cost/payment detail sensibly placed last. It is a single dense sentence with stacked clauses; every clause carries information, though the return-value enumeration could be tightened without loss.

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 and no annotations, the description compensates by enumerating return fields and the payment requirement, which is what an agent needs to decide and call correctly. Minor shortfall: nothing on error/empty-metadata cases or latency, which matter for a cross-source IPFS/Arweave fetch.

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 (contract, tokenId) are already documented with patterns, making 3 the baseline. The description adds only the mild constraint that contract is an ERC-721/ERC-1155 collection, which is marginally useful but does not add format, network, or validation detail beyond the schema.

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

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

The description states a specific verb (fetch metadata) and resource (ERC-721/ERC-1155 token on Polygon PoS) and enumerates exactly what comes back: collection name, owner, token URI, resolved metadata JSON, and image URL. That level of specificity distinguishes it from the sibling *nft_metadata tools on other chains and from polygon_contract_info / polygon_token_snapshot, which cover different resource types.

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

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

Chain scoping ('on Polygon PoS') and the ERC-721/ERC-1155 qualifier implicitly tell the agent when this tool applies, but there is no explicit when-to-use/when-not guidance and no named alternative (e.g. use polygon_contract_info for contract-level data, or polygon_token_snapshot for fungible tokens). Usage is inferred rather than directed.

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

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

With no annotations, the description carries the full load and does well: it discloses the paid x402 flow ('$0.01 USDC on Base'), the read-only, facts-only nature of the output, and the fact that the price/liquidity figures come from a specific pool source (deepest WPOL or USDC Uniswap v3 pool). It stops short of covering failure modes or what happens when no qualifying pool exists.

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 purpose, then the return payload, then the disclaimer and price. The long enumeration of output fields is justified since there is no output schema, though the single mega-sentence of fields could be broken up for faster scanning.

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?

Because there is no output schema and no annotations, the description must cover both returns and cost/auth behavior, and it does: it names every major returned field group and the payment mechanism. Remaining gaps are error handling and score methodology, which are secondary for a 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?

Only one parameter and the schema already documents it at 100% coverage ('Token contract address on Polygon PoS'). The description reinforces that this is an ERC-20 on Polygon PoS but adds no format, constraint, or edge-case guidance beyond the schema.

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

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

States a specific verb+resource pair ('Rug check and due-diligence snapshot of an ERC-20 token on Polygon PoS') and then enumerates exactly what the snapshot contains: risk score, token metadata, ownership status, proxy detection, bytecode-level owner functions, and DEX pricing. The chain name in the title and the explicit 'ERC-20 on Polygon PoS' scope separate it from its arbitrum/eth/optimism/base counterparts.

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 'rug check and due-diligence' plus 'Facts only, no buy or sell opinion' implies the pre-trade screening use case, but the description never states when to pick this over polygon_contract_info, token_risk_check, or prepayment_safety_check_lite. Usage is inferable rather than directed.

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

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

With no annotations, the description carries the full burden; it does valuable work by disclosing the paid model ('Costs $0.005 USDC on Base via x402'), which matters before invocation. However, it says nothing about failure behavior for an invalid or unfound hash, latency, or whether the transfer decoding is best-effort for non-ERC20 calls.

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: the content enumeration comes first, the cost caveat second. Every clause maps to something an agent needs before calling.

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?

A one-parameter read tool with no output schema, so the prose return-value inventory is doing real work and it is thorough. Near-complete; only error/edge behavior is unaddressed.

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?

Single parameter with 100% schema description coverage and an explicit 0x+64-hex pattern, so the schema already defines the input fully. The description adds no format detail or constraint beyond it — baseline 3 for a fully documented 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?

States a specific verb+resource ('Human-readable summary of a Polygon PoS transaction') and enumerates exactly what the summary contains: status, block and time, sender/recipient, value, gas, method selector, decoded ERC-20 transfers. The chain qualifier cleanly separates it from the eth_/base_/arbitrum_/optimism_transaction_summary siblings.

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 — you have a Polygon transaction hash and want a decoded overview — but there is no explicit when-to-use guidance, no exclusions, and no pointer to alternatives (e.g., polygon_token_snapshot or raw RPC). The agent must infer the selection context.

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

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

With no annotations, the description carries the burden and does disclose key traits: it is a live on-chain read, the response is human-formatted with symbol and decimals, the token list is capped at 20, and it costs $0.005 USDC on Base via x402 — a non-obvious payment prerequisite. It omits failure behavior for invalid/unverified token contracts and any rate-limit or caching 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 dense sentences with zero filler: output shape and scope first, then cost and provenance. Every clause carries information an agent needs.

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 tool with no output schema, the description usefully specifies the return shape (symbol and decimals per token) and the payment model. The remaining gap is how unlisted or invalid token addresses are handled.

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 are already documented in the schema; the description only restates the 'up to 20 ERC-20 tokens you list' constraint. Baseline 3 is appropriate since the schema does the heavy lifting and the description adds no syntax or format detail beyond 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?

States a specific verb+resource: reads native POL plus listed ERC-20 balances on Polygon PoS, with symbol/decimals formatting. An agent can tell this returns balances rather than a profile or allowance. It does not explicitly contrast with polygon_wallet_profile or polygon_erc20_allowance, which are the closest siblings.

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 resource name and chain, but there is no explicit when-to-use / when-not statement and no alternative named. An agent must infer that this is the tool for balances and that polygon_erc20_allowance covers approvals instead.

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

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

With no annotations, the description carries the full load and does well: it discloses the data provenance ('Alchemy's transfer index') and, critically, the payment requirement ('Costs $0.01 USDC on Base via x402'), which an agent must know before invoking. It omits rate limits and response shape, but for a read-only profiling tool the key operational facts are present.

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 scoping question, then a tight enumeration of returned data, ending on the cost. It is a single dense sentence plus cost clause with no redundant filler, though the enumeration is long enough to be slightly dense.

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 must convey return contents and it does so thoroughly, listing every major field group. Combined with the cost disclosure and data-source note, an agent has enough to call it correctly; only pagination/response-shape detail is absent.

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 a single parameter with 100% schema coverage, so the schema already documents the address and its format pattern. The description reinforces that it targets a Polygon PoS address but adds no format or validation nuance beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific framing question ('Who is this Polygon PoS address?') and enumerates exactly what the profile contains: wallet age, first funder, contract/EOA, balance and nonce, transfers, counterparties, USD large transfers. This concretely distinguishes it from siblings like polygon_wallet_balances and polygon_transaction_summary, though it never names them 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 'Who is this address?' framing implies the investigative use case, but there is no explicit guidance on when to choose this over polygon_wallet_balances, polygon_transaction_summary, or polygon_large_trades. Usage is inferable but not directed.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the output verdict tiers (ok/caution/block with plain reasons), the per-call price and payment rail ($0.02 USDC on Base via x402), and a liability disclaimer ("rules-based, not legal advice"). It stops short of stating that the call is read-only and sends no transaction, which is exactly the reassurance an agent needs before invoking a payment-adjacent 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?

Front-loaded with the decision question, then the check inventory, then return values, then cost. The comma-delimited check list is dense but each item is a distinct capability the agent may need to justify the call. No filler sentences.

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 4-parameter tool with no output schema and no annotations, the description supplies what an agent needs to call it correctly: coverage per chain, what the token parameter triggers, the shape of the returned verdict ('each check in full'), and the pre-call payment cost. Nothing material is omitted beyond the read-only reassurance noted above.

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 the baseline is 3; the description earns a bump by clarifying that Solana coverage is narrower ("wallet kind and activity on Solana" versus first funder and large transfers on the five EVM chains) and that supplying a token adds a 0-100 score. It never mentions the `expect` parameter, whose mismatch-behavior is left entirely to the schema.

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

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

Opens with a plain-language question that states the exact decision it supports, then enumerates the concrete checks performed (OFAC SDN, wallet age, EOA vs contract, first funder, large transfers, token risk score). The composite framing implicitly separates it from single-purpose siblings such as address_sanctions_screen, token_risk_check and the per-chain wallet_profile 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?

"One check before sending or accepting crypto" gives a clear triggering context and the chain list scopes where it applies. It does not explicitly route the agent to alternatives: prepayment_safety_check_lite (cheaper subset), address_sanctions_screen (sanctions only) or token_risk_check (token only) are never named, so the agent must infer when the full check is worth $0.02 versus a narrower one.

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 does the heavy lifting: it discloses the screening components, the return values (ok, caution, block with plain reasons), a key limitation ('Rules-based, not legal advice'), and the cost ($0.01 USDC on Base via x402). It does not cover rate limits, latency, or failure modes, but for a paid screening tool this is a strong disclosure.

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 with the core question and then packs useful details efficiently. It is slightly dense and could be split for readability, but every sentence contributes information without redundancy.

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

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

Given no output schema and no annotations, the description covers what the tool does, what it returns, its limitations, cost, and the alternative. Missing details like the threshold for 'recent large transfers' or how wallet age is computed are minor for an agent deciding to call it.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the chain enum and expect enum. The description adds no parameter-specific details beyond the general framing. Baseline 3 is appropriate when the schema is fully documented.

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 question ('Is it safe to pay this address?') and then precisely lists what the check covers: OFAC SDN, wallet age, EOA vs contract, first funder, recent large transfers across multiple chains, plus Solana wallet kind/activity. It explicitly distinguishes itself as the 'address-only version' of /check and notes 'No token score (use /check for that)', making the sibling relationship clear.

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

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

The opening question implies the primary use case (pre-payment safety check). The description explicitly names the alternative ('use /check for that') when a token score is needed, and clarifies this version is address-only. This gives the agent a clear when-to-use and when-to-use-the-other-tool signal.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the result is a read-only factual snapshot, not investment advice, and that invocation costs $0.01 USDC on Base via x402. It does not explicitly discuss permissions or rate limits, but the key behavioral traits are covered.

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 with the core purpose and packs a large amount of relevant output detail into a dense single sentence. It earns most of its length, though the long enumerations make it slightly harder to scan quickly.

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

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

There is no output schema, but the description fully enumerates what the snapshot returns: risk score, token metadata, authorities, Token-2022 controls, holder concentration, and Jupiter/DexScreener market data. For a single-parameter read tool, this is complete enough for an agent to know exactly what to expect.

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

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

Schema coverage is 100%, and the schema already documents the sole address parameter as a base58 Solana token mint address with a pattern constraint. The description adds context that the tool covers SPL and Token-2022 tokens, but it does not add syntax or format details beyond the schema.

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

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

The description states a specific verb and resource: a rug-check/due-diligence snapshot for Solana SPL and Token-2022 tokens. It enumerates the exact outputs (risk score, authorities, Token-2022 controls, holder concentration, market data), making the tool clearly distinguishable from sibling token snapshots on other chains and from wallet 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?

It clearly conveys the intended use case: due diligence and rug checking, with facts only and no buy/sell opinion. However, it does not explicitly name when to use this instead of overlapping siblings such as token_risk_check, so the routing guidance is clear but not exhaustive.

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 load and does real work: it discloses the paid model ('Costs $0.005 USDC on Base via x402'), the price data source (Jupiter), the sort order, the aggregation of dust/unpriced/empty accounts, and the exact transaction window ('newest 1,000, with a flag when history goes further back'). It omits failure behavior for a nonexistent address and any caching or rate-limit characteristics.

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 purpose is front-loaded in the first clause and every subsequent clause specifies a real return-value detail, which matters because there is no output schema. It is a single densely packed sentence that would scan better as a short list, but no clause is 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 one-parameter read tool with no annotations and no output schema, the description is unusually complete: it covers contents, price source, ordering, aggregation rules, activity window, and cost. The remaining gap is the absence of any error or edge-case behavior (invalid/nonexistent address, unsupported token programs) and no routing guidance relative to `solana_token_snapshot`.

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 and schema coverage is 100% (base58 pattern plus a description), so the schema fully documents it. The prose adds no format or validity guidance beyond that, and the 3-baseline 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.