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: on-chain reads only, no API key, POST body shape, a fixed $0.005 price, and the 402 fallback once the shared daily IP allowance is exhausted. It even flags a real risk caveat (an EIP-1967 proxy's logic can be swapped after you trust it), which is behavioral context no schema field could convey.

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

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

Front-loaded with the sibling relationship and the purpose, then the return fields, then payment terms — a sensible priority order. Some density in the payment parenthetical could be trimmed, but nearly 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?

No output schema exists, so the description enumerates the returned data itself (balances, activity, proxy status, risk band + flags), which is exactly what's needed. Payment semantics and the negative-result caveat round out a definition an agent can act on without further probing.

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 `address` and the base-only `chain` are already documented in the schema. The description restates POST `{ address }` but adds no syntax or format detail 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 a specific verb+resource (structural safety profile for any Base address) with explicit scope: EOA or arbitrary contract, and enumerates the exact return fields (contract-vs-EOA, balances, tx-count, ERC-20 recognition, ownership, mint() selector, EIP-1967 proxy). It also explicitly positions itself against the `address-safety` sibling as a naming alias, so an agent can tell the two apart without opening either schema.

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

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

Names the precise trigger situations — before sending funds, approving, or calling the address — which is exactly the decision point an agent needs. It also discloses the cost/free-trial condition, which affects when the tool is worth invoking at all.

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 so: it discloses that this is an on-chain-read-only, no-API-key operation, that a free daily trial exists and returns 402 when exhausted, and that the service is a paid x402 endpoint at a fixed $0.005. It even flags the trust caveat that an EIP-1967 proxy's logic can be swapped after inspection, which is exactly the kind of risk context an agent needs.

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 purpose and the when-to-use trigger, then packs returns, risk band, and payment model into a compact block. The parenthetical payment/free-trial sentence is dense but earns its place for a metered paid service; a slight trimming of nested parentheses would tighten it.

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

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

No output schema exists, so the description must describe returns — and it does, at field granularity. Combined with the cost, payment-failure, and free-trial behavior, an agent has everything needed to decide whether and how to call it without further guessing.

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 (address, chain) are already documented in the schema, including the Base-only constraint. The description reinforces 'any address, EOA or contract' and the POST body shape, but adds no syntax or format detail beyond structured data, 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 and resource — a structural safety profile for any Base address, EOA or contract — and names the decision it supports (send, approve, call). It also enumerates the exact outputs (contract-vs-EOA, ETH/USDC balance, tx-count, ERC-20 recognition, ownership, mint() selector, EIP-1967 proxy), which lets an agent distinguish it from siblings like token_safety or address_risk.

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 a concrete trigger: check before sending funds to, approving, or calling an address. The Base-only scoping implicitly routes other chains to address_safety_ethereum/address_safety_bsc, but no alternative tool is named explicitly as the choice for a different chain or for a token-level versus address-level check.

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: on-chain reads only, no API key, no side effects, daily free-trial allowance, the 402 fallback, the x402 USDC settlement requirement, and a fixed price. It also flags the EIP-1967 proxy caveat ('its logic can be swapped after you trust it'), which is exactly the kind of risk an agent cannot infer elsewhere.

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 purpose and trigger, then returns, then payment terms. Dense but nearly every clause earns its place; the payment/pricing sentences are the longest but are genuinely decision-relevant for an agent that may hit a 402.

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 returned signals (contract-vs-EOA, balances, tx-count, ERC-20 recognition, ownership, mint() selector, proxy status, risk band and flags). Combined with the disclosed payment model, an agent has everything needed to decide and call correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description still adds value by stating the wire format (POST `{ address }`) and reiterating that the address may be an EOA or an arbitrary contract, which is the semantic distinction that governs how the result should be interpreted. The `chain` parameter is not addressed, but the endpoint is single-chain by design.

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+resource+scope: a structural safety profile for ANY BSC address (EOA or contract). The chain qualifier in the name and the opening line separate it cleanly from address_safety, address_safety_ethereum, and address_risk 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?

Gives an explicit trigger: 'before an agent sends funds to it, approves it, or calls it.' That is a concrete use condition rather than an implied one. It stops short of naming an alternative or stating when-not to use it (e.g. when token_safety_bsc is the better fit for a token rather than an 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 full burden and does so well: it discloses on-chain-only reads, no API key needed, POST body shape, and the complete payment model (free-trial allowance, 402 response, x402/USDC-on-Base settlement requiring a funded wallet, fixed $0.005 price). It also enumerates what is and isn't detected (mint() selector, EIP-1967 proxy), which is exactly the context an agent needs to trust the result.

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 purpose and use conditions are front-loaded in the first sentence, and every clause (returns list, payment mechanics, price) earns its place by affecting invocation. The payment paragraph is dense and slightly verbose, which keeps it from a 5, but it is not 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, so the description must (and does) describe return values in detail: contract-vs-EOA, ETH+USDC balance, tx-count, ERC-20 recognition, ownership, mint selector, proxy status, plus risk band and flags. Combined with the full payment/error behavior, an agent has everything needed to call it and interpret the result 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 both parameters (chain and address) are already fully documented in the schema, including that only 'ethereum' is supported. The description's 'POST { address }' adds no syntax or format meaning beyond what the schema provides, so the 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 verb+resource+scope: a 'structural safety profile for ANY Ethereum address (EOA or contract)'. It clearly distinguishes itself from siblings like address_safety (chain-agnostic), address_safety_bsc, and token_safety_ethereum by naming the returned artifacts (contract-vs-EOA, balances, proxy status) that are specific to this check.

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

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

Gives explicit triggering context: use it 'before an agent sends funds to it, approves it, or calls it'. That is a clear when-to-use. However, it never names an alternative tool or the condition that would route the agent to address_safety or a token_* sibling instead, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the POST transport, the 402 failure mode for unpaid calls, that this is an x402 paid service settled in USDC on Base, the requirement for a funded MCP wallet, and a fixed $0.1 price. Return format and rate limits are not covered, but the payment and failure behavior is unusually well surfaced.

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 data returned is front-loaded before the payment mechanics, and every sentence carries information an agent needs (what data, how to call, what it costs). The payment parenthetical is dense but not wasteful; 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, no-output-schema, paid query tool, the description covers purpose, output content, transport, cost, and wallet prerequisite. Missing pieces are minor: no pagination/response-size hints and no error behavior beyond 402, but nothing essential to calling it correctly 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 `target` parameter already documents 'Domain, or any URL on it'. The description restates the target only implicitly ('A domain's backlink profile', 'POST `{ target }`') and adds no format or edge-case guidance beyond the schema, 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 (a domain's backlink profile) and enumerates the exact data returned (referring domains, dofollow split, authority rank, spam score, broken backlinks, composition by TLD/type/attribute/country). It is unambiguous what the tool does, but it never contrasts itself with the closest sibling, seo_audit, 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?

Usage is only implied: the agent learns it must supply a target via POST and that an unpaid call returns 402. There is no explicit statement of when to choose this over seo_audit or other SEO tools, nor any exclusion conditions, leaving alternative 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?

No annotations provided, so the description carries the burden. It discloses payment requirement and wallet setup, but does not mention rate limits, error handling, or consequences of insufficient funds. The description partially covers behavior but leaves gaps.

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

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

Two sentences, front-loaded with the primary action, and no wasted words. Every sentence adds necessary information about the service and prerequisite.

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

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

Given the tool has 3 parameters (2 required), no output schema, and no annotations, the description is minimal. It covers the payment aspect but lacks details on model availability, response format, or error scenarios, making it incomplete for a transactional 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% with detailed descriptions for each parameter (model, messages, max_tokens). The description adds no extra semantics beyond what the schema already provides, earning the baseline score.

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

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

The description clearly states the tool sends a chat completion request to an LLM via a specific paid service (true402). The verb 'send' and resource 'chat completion request' are explicit, and the service detail distinguishes it from sibling 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 mentions the paid nature and wallet requirement, providing context on when to use it (if funded). However, it lacks explicit guidance on when not to use it or alternatives, leaving the AI to infer from sibling tool names.

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: default exclusion of exploit-y outlier pools, percent-unit APYs with apyBase/apyReward split, explicit 402 failure mode, the x402/USDC-on-Base settlement requirement (funded wallet on the MCP server), and per-request pricing. That is exactly the beyond-schema behavior an agent needs before committing 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?

Purpose and data source are front-loaded in the first clause, then the POST shape, then return fields, then payment terms. Efficient overall, but the pricing model is stated three times ('Flat-priced per request', 'PAID x402 service', 'Price: $0.005 USD (fixed)'), which is mild 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?

No output schema exists, so the description must cover returns — and it does, naming APY units, the apyBase/apyReward split, TVL, stablecoin and ilRisk flags, and the DefiLlama poolId. Combined with the payment and failure-mode disclosure, an agent has everything needed to call this 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 every one of the 7 parameters is already documented, and the description only restates their names in the POST shape without adding format or semantics (e.g., substring-match behavior, limit-vs-sort ordering). Baseline 3 is correct 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 compound verb (filter + rank) plus a precise resource (live DeFi lending/staking pool APYs across all protocols/chains), with the data source and scale (~15k pools, DefiLlama) named. No sibling tool covers DeFi yields, so the scope is unambiguous without consulting 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?

Gives clear operational context for when this is the right call: you want APY-ranked pool data with optional chain/project/asset/TVL narrowing, and outlier pools are excluded unless opted in. It also explains the free-trial-vs-402 gate, which is usage-critical. It stops short of naming an alternative tool or a when-not-to-use case, so it lands at 4 rather than 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 well: it discloses the data source (on-chain creation receipt, no explorer), the Base limitation that `contractsCreated` returns null and `limits[]` reports it, the 402 on unpaid calls, and that the service is paid from the first call. Missing are failure modes (invalid or non-token address), latency, and any notion of how "FRESH" is thresholded.

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 verb/resource, then cost and Base caveats — a sensible ordering. It is dense with em-dash asides and one flourish ("no free trial on this stall"), but nearly every clause carries operational 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 3-parameter, no-output-schema, unannotated paid tool, it covers source of truth, the known data gap, the payment gate, and exact price — enough to call it correctly on the first attempt. What remains unstated (response shape beyond `limits[]`, fresh-wallet threshold, latency) is secondary but not trivial.

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 beyond it — the token is sent as POST `{ token }`, and it warns that `deep` (offered in the schema) is unavailable on Base today, a caveat the schema itself omits. That caveat is valuable but also leaves the agent unsure whether to pass `deep` at all.

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

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

States a specific verb and resource — resolves the deployer of a Base token and profiles that wallet's reputation (age, balance, fresh-wallet flag) — plus a scope qualifier that separates it from chain-structure checks. The Base-only framing and the `deployer_check_ethereum` sibling make the boundary obvious 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?

"Reputation context a structural/honeypot check can't see" positions it as complementary to honeypot/token_safety and implies when to reach for it. It also flags `deep` as opt-in and slower, which is a real usage decision. It never names an alternative tool or an explicit when-not-to-use case, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does so unusually well: it discloses the paid x402/USDC-on-Base model, the fixed $0.008 price, that unpaid calls return 402 with no free trial, and that a missing server-side explorer key yields a 503 that is not charged. It also notes the MCP server needs a funded wallet to settle, which is exactly the operational precondition an agent must know before calling.

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

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

Purpose is front-loaded and most sentences carry real information (reputation signals, payment model, failure modes). The payment point is restated three times (402 line, 'PAID x402' parenthetical, price line), and the 'no free trial on this stall' flourish costs space without adding an actionable fact.

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

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

For a tool with no annotations and no output schema, the definition is nearly self-sufficient: it covers the paid-call mechanics, error behaviors, prerequisites, and the shape of the reputation output. The one remaining gap is what happens when a deployer cannot be resolved (EOA-deployed contract, factory, or unknown address), which an agent would want before relying on 'fresh throwaway' as a negative signal.

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 `token`, `chain`, and the `deep` opt-in, making 3 the baseline. The description adds a little beyond the schema by stating the request shape (POST `{ token }`) and treating the call as a single-token lookup, but it does not reinforce the chain restriction or the `deep` flag's cost/benefit tradeoff, so it stays close to 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?

Names a specific verb and resource ('resolves the deployer of an Ethereum token and profiles that wallet's reputation') and enumerates the concrete signals returned: age/tx-count, balance, and a fresh-throwaway flag. It also differentiates itself from sibling surface checks by stating it supplies 'reputation context a structural/honeypot check can't see', so an agent can distinguish it from honeypot/token_safety 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?

Clearly frames when this tool earns a call: as the 'discriminating caution' layered on top of structural or honeypot analysis, with a warning about the common rug setup. It stops short of explicit when-not guidance or naming an alternative sibling (e.g., deployer_check multi-chain, address_safety_ethereum) for the case where a deployer reputation lookup is unnecessary.

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 burden, and it discloses the important behavioral traits: outbound URL fetch, deterministic scoring output, and a paid x402 flow with a 402 on unpaid requests plus price and settlement chain. It stops short of rate limits, timeouts, or what happens on an unreachable/invalid URL.

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

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

Three short sentences, front-loaded with what it does before the payment mechanics. Every clause carries information an agent needs — capability, request shape, payment gate, price — with no filler.

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

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

With no output schema, the description does the work of explaining the return value (present/missing per header plus a 0–100 score), and it covers the payment prerequisite that would otherwise cause silent failure. Only failure-mode behavior beyond the 402 case is left unstated, which is minor for a one-parameter read-only check.

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

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

Schema coverage is 100% for the single required 'url' property, so the baseline is 3; the description adds slightly by specifying the URL is sent in a POST body as `{ url }` and noting http/https scope consistent with the schema. No further semantics (e.g. redirect handling, query strings) are added.

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 + output: 'Fetch a URL and analyse its HTTP security headers … into present/missing + a 0–100 score.' The named header set (HSTS, CSP, X-Frame-Options) makes it unmistakably distinct from siblings like robots_check, seo_audit, or screenshot, and the return shape is stated up front.

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 invocation context — 'POST `{ url }`', 'unpaid returns 402', and a fixed $0.003 price with the funding prerequisite for the MCP wallet. That is strong operational guidance for whether the agent can actually call it, though it never states when to prefer this over the adjacent robots_check or seo_audit 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 full burden and does so richly: on-chain reads with no API key, ownership/mint/liquidity checks, and a gas-free eth_call honeypot simulation that round-trips a trade to detect buy-but-not-sell tokens. It also discloses the 0–100 score + risk flags output and the full payment/402 mechanics.

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?

Reasonably front-loaded with what the tool is and how it differs from token_safety before detailing checks and payment terms. It is dense and long, but the payment/402 details earn their place for an x402 paid service.

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, yet the description explains the return (0–100 score + risk flags) and the enumerated checks. Combined with the payment/auth mechanics, an agent has everything needed to decide and invoke correctly.

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

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

Schema coverage is 100% so the schema already documents both parameters. The description adds the POST { token } call shape and Base chain context but doesn't meaningfully elaborate on the `chain` parameter or token format beyond what the schema provides.

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

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

States a specific verb+resource (rug/honeypot safety check for an ERC-20 token on Base) and enumerates the concrete checks performed. It explicitly distinguishes itself from the sibling token_safety by noting it is the same check 'under the name buyers search for', so an agent can tell them apart.

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?

Clearly explains the payment context: free while the caller's IP has trial calls left, otherwise 402, with a fixed $0.005 price and the requirement for a funded wallet to settle. It signals this tool mirrors token_safety, though it doesn't state a positive reason to pick honeypot over that sibling beyond the naming angle.

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 well: it discloses the POST { seed } call shape, the 402 failure on unpaid requests, the x402/USDC-on-Base settlement requirement, the need for a funded wallet, and a fixed $0.05 price. It does not say whether the call has any side effects or how errors other than 402 surface, keeping it below 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 tight sentences, front-loaded with the purpose and output fields before the payment constraints. The parenthetical on payment rails is dense but earns its place because it changes whether the agent can call the tool at all.

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 correctly enumerates the returned fields (search volume, CPC, competition, search intent) and covers the payment precondition. The remaining gap is the unexplained language and location inputs, which matter for a multi-locale keyword API.

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

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

Schema coverage is only 50%: seed and limit are documented in the schema, while language and location have no description anywhere. The prose mentions only the seed term and the return metrics, so it does not compensate for the two undocumented parameters.

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?

A specific verb-plus-resource phrase ('Related and long-tail keyword ideas for a seed term') plus a list of the returned metrics tells the agent exactly what it gets. It does not explicitly distinguish itself from the sibling keyword_volume or ranked_keywords tools, so it stops short of a 5.

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

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

Usage is only implied: the tool generates new ideas, whereas the sibling names suggest volume-checking and ranking existing keywords. There is no explicit 'use this instead of X when Y' guidance, and no stated preconditions for the seed other than the schema's 80-char cap.

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 full burden and does so: it discloses that this is a paid x402 service settled in USDC on Base, that the calling MCP server needs a funded wallet, the fixed $0.15 price, and the 402 failure mode when unpaid. It also states the request shape (POST `{ keywords }`), which is unusual and otherwise undiscoverable from the schema alone.

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

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

Three tight sentences, front-loaded with the output content, then the batching/cost rule, then the payment mechanics. Every clause carries distinct information — no restatement of the tool name or 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 and no annotations, so the description must cover return values and safety/commercial behavior — it names the returned metrics and trend window and explains the payment flow and failure code. For a 3-parameter read tool this leaves nothing material an agent needs before calling 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 all three parameters (keywords, language, location) are already documented, and the description only restates the 200-keyword cap and per-call pricing. It adds no meaning for the language or location parameters beyond what the schema says.

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: monthly search volume, CPC and competition for a batch of keywords, plus a 12-month trend per term. The returned metrics are named explicitly, so an agent knows exactly what it gets without opening the schema. It is distinguishable from seo-oriented siblings such as ranked_keywords or keyword_ideas by being a batch volume/CPC 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 concrete operational guidance: batch up to 200 keywords in ONE call because pricing is per call, not per keyword — that directly shapes how an agent should invoke it. It does not name an alternative sibling or state when-not to use it (e.g., single-keyword or idea-generation needs), so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden and does well: it discloses the POST contract, the 402 response for unpaid requests, flat per-request pricing, the settlement chain (USDC on Base), and the hard prerequisite of a funded wallet. Remaining gaps are redirect/timeout behavior and whether failed or non-OG pages are charged.

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 comes first in one dense sentence, followed by the transactional constraints. The final parenthetical is information-rich but slightly cluttered; nothing is truly wasted for a paid service.

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 return fields (title, description, image, site name, favicon, canonical) and covering the payment prerequisite. For a single-parameter read tool, an agent has enough to call it correctly, though failure modes other than 402 are 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% with a single documented parameter, so the baseline is 3. The description adds only that the URL is sent as a POST body field, which marginally supplements the schema's "The page URL (http/https)" note.

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 verb and resource ("Fetch a URL and return its Open Graph card") and enumerates the exact returned fields, so the agent knows it is a pure card-metadata fetch rather than content extraction. It never names web_extract or screenshot, so the differentiation from those siblings must be inferred from the output list.

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

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

Implicit guidance only: the returned fields make clear this is for link previews/cards, and the payment block implies a pay-per-call service. There is no explicit statement of when to prefer this over web_extract or screenshot, nor any exclusion for non-HTML or paywalled URLs.

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 POST body shape, the complete return contents, the `coverage` block-range caveat that prevents misreading empty results, and the payment mechanics (free daily IP allowance, otherwise 402, x402 USDC settlement requiring a funded MCP wallet, $0.005 fixed). These are precisely the non-obvious behaviors an agent must know before calling.

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

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

Front-loaded with the purpose, then response contents, then the honeypot contrast and coverage caveat, then pricing. Every sentence carries information, though the payment/trial sentence is dense parenthetical material that could be tightened without 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?

For a paid read tool with no output schema and no annotations, the description covers the return payload, the critical interpretation caveat (`coverage` means absence of removals is not proof of safety), and the billing/auth path including the 402 condition. Nothing essential for correct invocation or interpretation is missing.

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

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

Schema description coverage is 100%, so both `token` and `limit` are already documented with type, range, and default. The description only echoes the POST signature `{ token, limit? }` and adds no semantics beyond what the schema states. 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+scope: 'Observed liquidity history for a Base token, from our own DEX archive,' and spells out exactly what the response contains (per-pool removal events, amount, block, tx hash, co-drained tokens). It explicitly contrasts itself with live honeypot simulation, which is a real sibling tool, so an agent can distinguish it 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?

Gives a clear selection rationale: use it to learn what ALREADY happened, since a re-seeded pool can pass a live simulation today. It also warns that absence of removals is bounded by `coverage`, which is a usage caveat. It does not explicitly name `liquidity_pulls` as the alternative for a different question, so the routing guidance is clear but not fully 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 burden well: it discloses the POST interface, what each event contains (pool, token, WETH/USDC amount removed), the free-trial daily allowance shared across callers, the 402 fallback, and the x402/USDC settlement requirement with a fixed $0.003 price. Remaining gaps are minor — no ordering/pagination behavior or error semantics beyond 402.

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 purpose and the parameter shape before the payment caveats, so the essential selection information comes first. The payment paragraph is comparatively long but is genuinely decision-relevant for this paid tool, 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?

With no output schema and no annotations, the description supplies the return shape (pool, token, removed amount) and the full access/payment model, which is the information an agent most needs here. It stops short of explaining result ordering or how to detect an empty 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 coverage is 100%, so each parameter is already documented in the schema. The description adds interpretive framing, notably that minQuote corresponds to rug magnitude and that since is block-based, but does not supply syntax or defaults beyond what the schema states. 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 verb and resource: liquidity-pull/rug alerts, defined concretely as burn (liquidity-removal) events on recently launched DEX pools, and scopes it to the new-pairs watcher's set, which implicitly separates it from the broader liquidity_history sibling. It does not explicitly name the sibling it replaces, so 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?

Gives explicit usage context (cross-check the token with /v1/token-safety) and states the payment/access precondition for calling it. There is no explicit 'use this instead of liquidity_history' routing, but the recent-pairs scoping and the cross-check recommendation give an agent enough to decide.

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 provided, so description carries full burden. It discloses return fields (id, provider, prices), pricing model (3% over cost, min fee), and payment method (x402). Missing details on pagination or limits, but acceptable for a listing 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?

Single paragraph, front-loaded with purpose. Concise but could be slightly shorter. No wasted 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?

No output schema, but description details return values (id, provider, prices). Covers essential behavior. No obvious gaps given zero parameters.

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?

Input schema has 0 parameters and schema description coverage is 100%. Description does not need to add param info; baseline 4 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 states the tool lists LLM models with live pricing, using specific verbs ('list', 'returns'). It distinguishes from sibling tools (e.g., chat, address_safety) which have unrelated purposes.

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: when an agent needs to pick a model and know cost before paying. No explicit when-not or alternatives, but sibling tools are unrelated, so no confusion.

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

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

With no annotations provided, the description carries the full behavioral burden and does so thoroughly: it discloses the background log-watcher source, the returned pair fields, free-trial IP-based allowance, 402 fallback, x402 paid service details, USDC on Base settlement, required funded MCP wallet, and fixed price. This is unusually complete behavioral context for a paid data-feed tool.

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

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

The description is dense and front-loads the purpose before moving into parameters, return fields, bundling advice, and payment terms. It is somewhat long and repeats the paid nature across multiple clauses, but every sentence carries useful operational information.

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

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

Given the tool has no output schema, the description compensates by explaining the returned pair fields (new token, quote, pool, fee|stable, block, approximate age). It also covers payment/free-trial behavior and pre-trade safety bundling, leaving no major gap for an agent deciding whether and how 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 four parameters and their types. The description lists the parameter names in POST syntax but adds no meaningful syntax, format, or edge-case guidance 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 uses a specific verb and resource: it lists recently-created Base DEX pairs from Uniswap V3 and Aerodrome via a background log-watcher. It clearly distinguishes the tool as a fresh token launch feed for trading agents/snipers, which is a distinct purpose from siblings like token_safety or whale_swaps.

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 context for use (fresh token launches for trading agents/snipers) and names a complementary alternative by recommending bundling with /v1/token-safety for a pre-trade rug/honeypot check. It does not explicitly say when not to use it or compare against other siblings, so it falls short of a full 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 behavioral burden, and it discloses important traits: the service is paid via x402/USDC on Base, requires a funded wallet, returns 402 when free-trial calls are exhausted, and has a fixed $0.005 price. It does not cover broader error behavior or rate-limit details beyond the daily trial allowance, so it falls short of complete transparency.

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

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

The purpose is front-loaded and the payment details are relevant for a paid service. There is minor redundancy between 'Flat-priced per request' and the explicit fixed price, but the description is not bloated and each major sentence serves a purpose.

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 usefully names the normalized return fields: probability outcomes, USD volume, and close date. It also explains the free-trial and 402 behavior. It is nearly complete, though it could be more explicit about freshness or response structure.

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

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

Schema description coverage is 100%, so the input schema already documents both parameters. The description repeats the POST shape 'query, limit?' but adds no additional syntax, filtering behavior, or semantics 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 states a specific verb ('Keyword-search'), resource ('live prediction markets'), venue scope (Polymarket, Limitless, Manifold), and return shape. No sibling tool overlaps with prediction markets, so an agent can route to it without opening another 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 purpose: use it to search live prediction markets. It explains free-trial versus paid conditions, but does not explicitly say when to use this tool versus alternatives or when not to use it. Since sibling tools are unrelated, the lack of routing guidance is less damaging but still a gap.

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 well: it discloses deterministic behavior, the POST dispatch shape, free-trial allowance behavior, the 402 response when unpaid, USDC/Base payment requirements, and a fixed price. It still omits return format and error behavior for invalid function params.

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 and function list are front-loaded, and most sentences earn their place by covering dispatch syntax, examples, and payment behavior. It is dense and run-on, with some redundancy around flat pricing, but not bloated.

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

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

For a 10-function calculator endpoint with nested params and no output schema, the description covers payment behavior well but leaves notable gaps: return values are undescribed, and parameter shapes are only shown for 3 of 10 functions. It is minimally sufficient to invoke the tool but not fully complete.

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

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

Schema coverage is 100% at the top level, so baseline is 3, but the description adds meaningful examples for black_scholes, kelly, and sharpe parameter shapes. It does not document parameter shapes for the other functions, so it is helpful but incomplete 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 resource (deterministic finance calculators) and a dispatch interface, then enumerates the exact functions available. It is immediately clear what the tool does and how it differs from the surrounding SEO/web3 tools.

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

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

The description implies usage for finance calculations by listing the calculators, but it does not explicitly say when to use this tool versus alternatives or when not to use it. The payment/free-trial notes are useful context but are not usage-selection guidance.

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

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

With no annotations, the description carries the full burden and does well on the biggest behavioral trait: it discloses that this is a paid x402 service, that an unpaid call returns 402, that settlement is USDC on Base, and that a funded wallet is required, plus a fixed $0.05 price. It omits that the POST is a read-only query (no mutation warning needed) and says nothing about rate limits or other error modes.

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

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

Three short sentences with the data description front-loaded, followed by the call shape and the payment caveat. No filler, though the parenthetical payment detail is dense and slightly buried mid-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, and the description helpfully names the returned fields and the payment flow, which covers the major unknowns. However, it leaves the language/location parameters and any pagination or result-limit behavior unexplained, which matters for a 4-parameter query tool.

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

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

Only 'target' is hinted at ('a domain') and nothing is said about limit, language or location. With schema description coverage at 50%, the description needed to compensate for the two undocumented parameters and does not — an agent gets no guidance on how language/location shape results.

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

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

The description states a specific resource and scope: keywords a domain already ranks for in organic search, and it enumerates the returned metrics (position, volume, CPC, competition). That implicitly separates it from keyword_ideas and keyword_volume, though neither sibling is named explicitly.

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

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

Usage is implied by 'already ranks for' — use this for existing organic rankings rather than new keyword discovery — but the description never states when to prefer it over keyword_volume, keyword_ideas or serp. No 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 disclose the critical behavior an agent would otherwise trip on: POST body shape, 402 on unpaid requests, x402/USDC-on-Base settlement, the need for a funded wallet, and a fixed $0.003 price. It stops short of describing response structure, caching, or failure modes beyond the 402.

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 capability is front-loaded in the first sentence and the payment caveats are compressed into the remainder. The parenthetical is dense but every clause (402, x402, USDC/Base, funded wallet, price) is decision-relevant for an agent, so little waste remains.

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

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

For a single-parameter read tool with no output schema and no annotations, the description covers what it returns at a high level (crawler allow/block, sitemaps) and the payment gate that would otherwise cause silent failures. A bit more on response shape would be the only remaining gap.

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

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

Schema coverage is 100% and the single `url` param is documented as "Any URL on the site," so the schema already does the work. The description only adds that the value is POSTed, which is marginal extra meaning; 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: fetch robots.txt + llms.txt and report AI-crawler allow/block status plus sitemaps. That scope is distinct from the nearest siblings (headers_check, seo_audit), so an agent can pick it without opening either schema.

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

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

Usage is implied by the output described (AI crawler access + sitemaps), but there is no explicit when-to-use/when-not or named alternative such as headers_check or seo_audit. The only explicit guidance is the payment prerequisite, not task routing.

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 well: it names the rendering engine (headless Chromium), the exact return payload format (base64 PNG in JSON), the 402 payment-failure behavior, the x402/USDC-on-Base settlement model, and a fixed $0.004 price. These are behavioral facts an agent cannot get from 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?

Front-loaded with the core action and return format, then the payment terms. Slightly redundant in saying both 'flat-priced per request' and 'Price: $0.004 USD (fixed)', but no sentence 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?

There is no output schema, yet the description states exactly what comes back (base64 PNG JSON) and covers the payment/auth requirement that would otherwise block a call. For a 3-parameter paid endpoint, nothing an agent needs before invoking 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% and already documents url, width (320–1920, default 1280), and fullPage (clamped to 8000px). The description only restates the payload shape as `{ url, fullPage?, width? }`, adding default/optionality emphasis but no new semantics, 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 and resource ('Render a web page in headless Chromium') plus the concrete output ('PNG screenshot as base64 JSON'). That clearly separates it from siblings like web_extract, link_preview, and serp, which return text/link/metadata rather than rendered images.

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 the precondition that an unpaid request returns 402 and that the server needs a funded wallet, which is essential usage context. It never states when to prefer this over web_extract or link_preview, nor any when-not conditions beyond payment, so usage is implied rather than 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 so thoroughly: it discloses the x402 payment model (USDC on Base, funded wallet required), the 402 response for unpaid calls, per-page pricing, the 10-page deployment cap, and the distinct return shapes for single vs batch. It even warns that dynamic pricing can exceed a fixed MAX_PAYMENT_USDC ceiling and must be raised — exactly the operational context an agent needs.

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 and call shapes, and nearly every clause carries actionable information for a paid tool. Minor deduction for stating pricing twice with slightly different framings ($0.02/page then $0.02–$0.2 USD/page DYNAMIC), which creates a small internal tension in an otherwise tight paragraph.

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 describing both return shapes (flat report vs `{ count, succeeded, pages }`). Combined with the payment mechanics, batching limits, and per-page pricing, an agent has everything needed to invoke this correctly and anticipate the failure mode.

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 would be 3, but the description adds meaning beyond the schema: it clarifies the `mode` default in prose and, critically, resolves a conflict by noting that although the schema allows up to 20 URLs, this deployment prices at most 10 per request. That is a genuine semantic contribution, though `mode` enum values are not elaborated.

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

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

States a specific verb and resource — audit web pages for SEO + GEO — and immediately distinguishes the two call shapes (single `url` vs `urls` batch). The scope is narrow and clearly different from nearby sibling tools like `serp`, `backlinks`, or `web_extract`.

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 clearly signals when to use the batch form versus the single form, which is real guidance. However it never says when to reach for this tool instead of siblings such as `serp`, `backlinks`, or `keyword_volume`, nor does it give exclusions (e.g. robots-blocked or non-HTML URLs).

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 unpaid returns 402, there is no free trial, payment is USDC on Base requiring a funded wallet, and the fixed $0.02 price. It also notes the 'live' nature and describes what is read. Minor gaps remain (e.g., no rate limit, caching, or explicit read-only/no-side-effects statement), but overall transparency is high.

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 is front-loaded in the first sentence, with return details and payment constraints following. The parenthetical payment sentence is information-dense and slightly cluttered, but overall there is little waste and structure is logical.

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 convey return values — it does so by listing result fields and SERP features. It also explains the payment model, which is critical for this paid service. Completeness is strong, though some parameter behavior (depth, device, language, location) relies entirely on the schema.

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 83%, so the schema already documents the six parameters thoroughly. The description adds a bit of value by clarifying that `target` reports a domain's position and that null means 'not in the results read', but it omits mention of depth/device/language/location and mostly reiterates what the schema provides. 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 verb and resource ('Live Google organic results for one query') and enumerates the returned fields (position, domain, URL, title, snippet, SERP features, target position). This clearly distinguishes it from siblings like keyword_volume, ranked_keywords, or backlinks, which serve different SEO data needs.

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?

Provides clear usage context: one query at a time, optional target for domain position, POST body shape, and that unpaid calls return 402. It does not explicitly name alternatives or state when-not-to-use conditions, but the payment model and per-query scope give strong practical guidance.

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

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

With no annotations, the description carries the full burden and does so: it discloses payment mechanics (PAID x402, USDC on Base, MCP server needs a funded wallet to settle), a fixed price, no free trial, the POST body shape, and the failure semantics — each section reports its own status and limits[] enumerates what could not be established, with the reason stated ('a silently missing section reads as reassurance'). It also states a non-obvious result rule: the verdict is inherited and may only be escalated, never softened.

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 payload inventory before the caveats and pricing, and most sentences carry real information (status/limits semantics, verdict escalation rule). A few phrases are promotional padding ('what distinguish a bad token from a serial rugger', 'No free trial on this stall') that could be trimmed 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?

There is no output schema, so the description must describe return values — and it does, section by section, including the archive's per-removal fields (amount/block/tx) and the operator-linkage signal. Combined with the payment and limits[] disclosure, an agent has everything needed to decide, invoke, 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 coverage is 100%, so both parameters (token, chain) are already documented in structured form; the description only restates the required token via 'POST `{ token }`'. It says nothing about the chain parameter or its base-only constraint beyond the framing. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

Opens with a specific verb-and-resource framing ('Everything we know about a Base ERC-20, in one call') and then enumerates the exact contents: conformance, ownership, mint-capability, honeypot simulation, rug/whale activity, verdict, deployer reputation, and the durable liquidity archive. It explicitly contrasts itself with 'the cheaper report' (token_report), so an agent can separate it from token_safety/token_report 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?

Usage context is clear — this is the escalation path when the two extra sections (deployer reputation, operator-linked liquidity removals) matter, i.e. 'what distinguish a bad token from a serial rugger'. It names the cheaper alternative implicitly rather than by tool name and gives no explicit 'do not use this for X' exclusion, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does much of it: it discloses the composite scope, the return shape (avoid|caution|ok verdict plus underlying reports), the POST invocation, and a detailed payment model (x402 USDC on Base, $0.008 fixed, free-trial IP allowance, otherwise HTTP 402). It omits latency, caching, and failure behavior when the upstream simulations error, 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?

Front-loaded with the core value proposition and the enumerated checks before pricing details, so an agent gets the essentials in the first sentence. Slightly verbose, with some marketing framing ('flagship') and a parenthetical about the MCP server wallet that could be shortened, but nearly every clause carries operational 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, and the description compensates by describing what is returned: a single verdict with reasons plus the underlying component reports. Combined with the payment/trial semantics and the explicit supported chain, an agent has everything needed to decide and invoke correctly.

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

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

Schema coverage is 100% and both parameters are fully documented in the schema, so the baseline of 3 applies. The description's 'POST `{ token }`' and 'Base ERC-20' phrasing only restates what the schema already says about token and chain, adding no new syntax or format 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 ('composite token-safety check for a Base ERC-20') and enumerates exactly what is bundled (ERC-20 conformance, ownership, mint-capability, liquidity depth, honeypot simulation, rug/whale activity). An agent can distinguish it from token_safety, liquidity_pulls, and whale_swaps 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?

Explicitly frames the tool as 'one call instead of five' and 'cheaper than buying token-safety + liquidity-pulls + whale-swaps separately', which routes the agent to the right sibling set. It also constrains scope to Base. It stops short of stating when NOT to use it (e.g. when a single narrow check suffices), so it is clear context rather than a full decision 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 provided, the description carries the full burden and does so well: it discloses the safety checks performed, the verdict output, the free-trial/402 payment behavior, the x402 USDC-on-Base settlement requirement, the fixed price, and the BSC-only data limitation. The only minor omission is an explicit read-only statement.

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

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

The description front-loads the composite purpose and verdict output, then adds payment and chain-caveat details that are genuinely useful for invocation. It is slightly long and parenthetical, but no sentence is clearly wasteful.

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

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

Given no annotations and no output schema, the description supplies enough for an agent to select and invoke the tool: scope, bundled checks, verdict output shape, pricing/auth model, and chain-specific limitations. The exact fields inside 'underlying reports' are vague, but that is not essential for selecting or calling the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both the chain and token parameters. The description repeats 'POST {token}' but adds no syntax or meaning beyond what the schema provides.

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

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

States a specific verb and resource: it 'runs the full token-safety check' for a BSC ERC-20 and returns an avoid|caution|ok verdict. It distinguishes itself from separate sibling tools by naming the token-safety, liquidity-pulls, and whale-swaps components it bundles.

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 frames this as a one-call alternative to separate tools and notes the cost advantage, which gives clear usage context. It also warns that recentPulls and recentWhaleSwaps are always empty on BSC, but it does not give a direct 'use sibling X instead when...' exclusion 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 provided, the description carries the full behavioral burden and does so well: it discloses the avoid|caution|ok verdict, that underlying reports are returned, free-trial behavior, 402 fallback, x402 paid settlement requirements, price, and the Base-only limitation that makes recentPulls and recentWhaleSwaps empty on Ethereum.

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 main purpose is front-loaded and the operational caveats are packed efficiently into one paragraph. It is somewhat dense and repeats the paid/free-trial framing across separate clauses, but most sentences carry useful selection or invocation 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 complex paid composite with no output schema, the description gives enough context to select and invoke it correctly: what it checks, what verdict it returns, what it replaces, payment behavior, and chain-specific caveats. The remaining response-shape details are not required for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents both the required token address and optional chain field. The description reinforces the token input and Ethereum-only scope but adds no syntax or format semantics beyond what the schema already provides.

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

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

The description states a specific resource and job: a composite Ethereum ERC-20 token-safety report that runs conformance, ownership, mint-capability, liquidity and honeypot checks. It distinguishes this from sibling-style separate purchases by framing it as 'one call instead of five' and naming the underlying checks it replaces.

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: use this for a full token-safety check and it is cheaper than buying token-safety, liquidity-pulls and whale-swaps separately. It does not explicitly say when not to use it, such as when only a single narrow check is needed, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that reads are on-chain with no API key, that the honeypot check is a gas-free eth_call round-trip, that the response is a 0–100 score plus risk flags, and it details the payment model and the 402 fallback when the free daily allowance is exhausted. Minor gaps remain (no stated latency/caching or handling of invalid addresses), 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?

Purpose and the list of checks are front-loaded, and the dense single paragraph has little filler. The payment information is somewhat repetitive ('Unpaid: free while... otherwise returns 402' followed by the PAID x402 parenthetical and a separate price line), costing a bit of tightness.

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 tool with no output schema and no annotations, the description covers the necessary ground: inputs, what is checked, what is returned (score + risk flags), and the billing/authentication behavior. What is missing is an indication of what individual risk flags mean or how the score is composed, but that is a modest 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 both parameters (token, chain) are already documented in the schema. The description adds only the body shape ('POST `{ token }`') and confirms the Base-chain focus; it adds no syntax or validation detail for the address beyond what the schema provides. 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 verb and resource ('Rug/honeypot safety check for an ERC-20 token on Base') and enumerates the concrete checks performed: ERC-20 conformance, ownership renounce, mint capability, liquidity across Uniswap V3 + Aerodrome, and a honeypot simulation. The chain qualifier ('on Base') readily distinguishes it from the sibling variants token_safety_ethereum, token_safety_bsc and token_safety_solana.

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 scope ('ERC-20 token on Base') implies when the tool applies, and the payment/free-trial conditions are spelled out clearly. However, it never explicitly routes the agent away from overlapping siblings such as honeypot, token_dossier or address_safety, so the when-to-use decision is left to inference from the chain suffix.

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

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

With no annotations provided, the description carries the full behavioral burden and does so thoroughly: it explains that checks are on-chain with no API key, states it returns a 0–100 score plus risk flags, and details the payment model (free daily trial, then HTTP 402, x402 USDC-on-Base settlement, $0.005 price). This is exactly the kind of invocation-critical context an agent needs before calling.

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

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

The purpose and chain are front-loaded, and the payment details, though dense, are necessary for invocation. The single-paragraph structure with heavy parentheticals makes it slightly harder to scan than ideal, but every sentence contributes 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?

There is no output schema, so the description compensates by stating the return value (0–100 score + risk flags). Combined with full parameter documentation in the schema and complete payment/authentication details, an agent has everything needed to decide whether and how to call the tool.

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

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

Schema description coverage is 100%, so both parameters (token and chain) are already well documented in the schema. The description only repeats 'POST {token}' and the chain restriction, adding no syntax or format detail beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Rug/honeypot safety check for an ERC-20 token on BNB Smart Chain (BSC)'. It enumerates the exact checks performed (ERC-20 conformance, ownership renounce, mint capability, liquidity depth, honeypot simulation), making it easy to distinguish from sibling tools like token_safety_ethereum or honeypot.

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 restriction ('BSC') is implied by the name and schema, but the description never explicitly routes the agent to alternatives such as token_safety_ethereum or token_safety for other chains, nor does it say when not to use this tool. Usage is strongly implied by the chain-specific name and scope, but no explicit comparisons are offered.

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 well: it discloses that reads are on-chain with no API key, that the honeypot test is a gas-free eth_call simulation, that the result is a 0–100 score plus risk flags, and it fully explains the payment/auth profile (free-trial 402 boundary, x402 USDC on Base, need for a funded MCP wallet, fixed $0.005 price).

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 and checks, then the return shape and payment terms. The payment explanation is somewhat dense and slightly redundant (free-trial/402 followed by a paid x402 note and price), but every part is operative information for an agent deciding whether it can 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 two-parameter tool with no output schema, the description supplies everything needed: what is checked, what is returned, that it is read-only/simulation-based, and crucially the payment and funding requirements that determine whether a call will succeed.

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 baseline is 3. The description adds only a POST `{ token }` hint and re-states the Ethereum-only scope; it does not add format or validation detail beyond what the schema already documents for `token` and `chain`.

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/honeypot safety check for an ERC-20 token on Ethereum. It enumerates the concrete checks (ERC-20 conformance, ownership renounce, mint capability, liquidity depth, buy/sell simulation) and thereby distinguishes itself from siblings like token_safety_bsc, token_safety_solana, token_report_ethereum, and honeypot.

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 on when the tool works for free (caller's IP with free-trial calls left) versus when it returns 402, plus the payment mechanics. It does not explicitly route the agent away from near siblings such as token_report_ethereum in favor of this one, so it stops short of full when/when-not guidance.

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

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

No annotations exist, so the description carries the full burden and does so well: it discloses the return shape (0–100 score + risk flags), the exact semantics of each flag (freeze authority = honeypot, permanentDelegate = tokens movable out of wallet, transferHook = issuer can reject transfers), and the full billing behavior — free while the IP has trial calls, 402 otherwise, x402 USDC-on-Base settlement requiring a funded MCP wallet, fixed $0.005 price.

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 the list of checks are front-loaded, which is the right structure. The trailing payment paragraph is dense (parenthetical 402/trial mechanics) and slightly bloats an otherwise tight definition, but every sentence still carries operational 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 missing pieces an agent needs: the output shape, the meaning of each risk flag, the input format, and the payment/failure mode (402). Only latency, pagination-equivalent limits, and the exact flag list returned are unspecified, which is acceptable for this 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 already documented, and the description only restates the base58 mint format already present in the schema. It adds no new meaning for the optional 'chain' parameter (e.g. that it is fixed/defaulted on this endpoint), 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 precise verb and resource — a rug/trap safety check on a Solana SPL or Token-2022 mint — and enumerates exactly what is inspected (mint authority, freeze authority, Token-2022 extensions, pool liquidity). It explicitly distinguishes itself from the sibling 'honeypot'/'tx_preflight' style tools by declaring it is NOT a buy/sell simulation and that no eth_call round-trip exists on Solana.

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

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

Gives clear usage context: call it when evaluating a Solana mint for rug/honeypot risk, and explicitly excludes the buy/sell-simulation use case, implicitly routing that need and the EVM equivalents (Base/Ethereum/BSC stalls) elsewhere. It does not name the specific Solana-adjacent siblings (token_dossier, token_report) it should be paired with, so the routing is strong 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?

No annotations exist, and the description carries the full burden well: it discloses the security property (no key, no signature, cannot broadcast or front-run), the epistemics of the result (never returns 'safe'; a clean result means nothing was found and `limits` says so every time), and the payment behavior (free-trial IP allowance, otherwise 402, $0.008 fixed, MCP server needs a funded wallet). These are exactly the traits an agent cannot infer from 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?

Front-loaded with the action and then the three lenses; every clause is substantive. The payment paragraph runs two sentences where one would do, a minor redundancy but 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?

With no annotations and no output schema, the description still tells the agent what comes back (simulation, decoded intent, counterparty liquidity-removal history, plus a `limits` array), what a clean result means, and the payment failure mode (402). Nothing needed 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% and the field descriptions are already substantive (e.g., 'Asserted, never proven — no signature is taken'). The description only restates the object shape `{ from, to, data?, value? }`, adding no format or edge-case guidance 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?

States a specific verb and resource ('Check a Base transaction BEFORE signing it') plus the exact input shape it accepts. It is clearly distinguishable from sibling safety tools (token_safety, address_safety, honeypot), which inspect tokens/addresses rather than a specific unsigned transaction.

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

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

Gives an explicit timing condition ('BEFORE signing it') and the invocation contract (POST an unsigned transaction to get three lenses). It does not name a sibling alternative or state when-not to use it, but the use case is unambiguous.

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 useful work by disclosing the paid x402/USDC payment flow, price, wallet requirement, and 402 failure mode. It does not cover other operational behavior such as content limits, JavaScript rendering, timeouts, or response truncation.

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 and output are front-loaded, and the payment requirements are clearly stated. There is minor redundancy between 'Flat-priced per request' and 'Price: $0.005 USD (fixed)', but no major waste.

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

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

For a one-parameter fetch/extract tool with no output schema, the description adequately states the returned content and the key payment prerequisite. It leaves some operational details unstated, but an agent has enough to understand and invoke the tool.

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

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

The schema already fully documents the single url parameter with 100% coverage, so the baseline is 3. The description adds the HTTP method and URL payload shape but no additional semantic constraints beyond what the schema provides.

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

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

States a specific verb and resource: fetch a web page and return extracted text, markdown, title, description, and links. It is clear what the tool does, though it does not explicitly distinguish itself from nearby sibling tools such as link_preview or screenshot.

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 payment condition is explained, including that unpaid requests return 402 and a funded wallet is needed, but there is no explicit guidance on when to use this tool versus alternatives like link_preview or screenshot. Usage is implied by the purpose rather than routed against 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 burden and does so: it discloses the returned fields (pool, token, quote, USD size, direction, block + approx age, txHash), how usdValue is derived (quote side via WETH×ETH-USD or USDC), and the complete payment model including the 402 response, free-trial allowance shared across IP, and the fixed $0.005 price.

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?

Data scope and return shape are front-loaded, then the parameter signature, then payment terms — a logical order. It is dense and the payment/trial detail is verbose, but nearly every sentence contributes operational information 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?

There is no output schema, and the description compensates by enumerating the return fields and their meaning. Combined with the disclosed cost/402 behavior for an unannotated paid tool, an agent has what it needs 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 defaults (min 10000, limit 1–200 default 50) and enum meanings are already documented. The description restates the parameter set and adds a mild clarification that direction is 'buy/sell of the token' and that usdValue is the quote side, but nothing beyond what the schema conveys.

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 (recent large DEX swap events on Uniswap V3 + Aerodrome, Base pools), the qualifying threshold ($-value), and frames the intended signal (whale-following / copy-trading). It also scopes itself to 'the pools the new-pairs watcher tracks', which distinguishes it from siblings like new_pairs and liquidity_pulls.

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 'a whale-following / copy-trading signal' implies when the tool is useful, and the pool-scope note implies its boundary. However, it never states when NOT to use it or names an explicit alternative among the many sibling tools (new_pairs, liquidity_pulls, token_dossier), so selection still requires inference.

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