StealthGuard 402

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real value beyond them: output is 'sanitized and summarized for context windows' (pre-processed, token-bounded content) and carries a cost of $0.002 USDC on Base, which is a non-obvious payment behavior an agent must account for.

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

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

Two sentences, front-loaded with the resource and scope, followed by the sanitization/summarization trait and the price. No filler or redundancy; every clause carries information.

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

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

With no parameters, an existing output schema, and annotations covering the safety profile, the description is nearly complete. It could state the freshness cadence or paper count behind 'Latest', but the cost disclosure and sanitization note cover the most agent-relevant gaps.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description adds nothing about parameters, which is correct since there are none, and the empty schema is consistent with a fixed latest-papers feed.

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 ('ArXiv AI agent security and autonomous reasoning papers') with a clear topical scope that separates it from sibling feeds like github_trending_agents and hackernews_ai_digest. It is a noun phrase rather than a verb+object, but 'Latest ... papers' still communicates the retrieval action unambiguously.

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

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

There is no explicit when-to-use guidance, no statement of prerequisites, and no named alternative among the many sibling feed/digest tools. The agent must infer usage purely from the topic label.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, open-world), so the bar is lower. The description still adds real context beyond them: the 2-hour freshness window, the automated verdict behavior, and the $0.003 USDC per-call cost on Base. It stops short of explaining edge cases such as pools with missing verdicts.

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

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

Two tight sentences, front-loaded with the resource and scope, followed by the distinct value-add and cost. Every clause earns its place, including the pricing disclosure which is genuinely useful for an agent deciding whether to call.

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 an output schema present, return format needn't be described, and with zero parameters there is no input surface to document. The description covers scope, verdict and cost, but does not explain what the TRUST/BLOCK verdict signifies or the volume/rate of pools returned, leaving a small gap.

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

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

This tool takes zero parameters, so the baseline expectation is 4 and there are no parameter semantics to clarify. The description correctly avoids inventing or implying any inputs.

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

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

States a specific resource (newly created Base liquidity pools), a precise time scope (last 2 hours), and a distinctive value-add (automated TRUST/BLOCK verdict). An agent can tell it apart from siblings like base_trending_tokens or solana_trending_safe 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?

The description never says when to reach for this tool versus alternatives such as base_trending_tokens or the Solana equivalent. It implies a monitoring use case but offers no explicit context, exclusions, or sibling 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?

Annotations already declare readOnly/openWorld/non-destructive, so the safety profile is covered. The description adds genuinely non-structural context: the results are pre-screened for honeypots, malicious taxes, and prompt injections, and the call costs $0.003 USDC on Base. The paywall cost is important behavioral context an agent cannot get from annotations or 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?

Two tight sentences with no filler; the core purpose is front-loaded and the cost/network detail follows. Every clause earns its place.

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

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

An output schema exists, so return values need not be described. The description covers source, safety pre-screening, and payment cost, which is enough to call the tool correctly; only cross-sibling routing guidance 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate. Per the rubric, a 0-parameter tool baselines at 4.

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

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

States a specific resource and scope: top trending Base DEX pairs, with the data source (DexScreener) named. It implicitly reads as the Base counterpart to solana_trending_safe and distinct from base_new_pools, but it never explicitly differentiates itself from those siblings.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no alternatives named. An agent must infer from 'trending' vs the sibling 'base_new_pools' and 'solana_trending_safe' on its own, which is thin routing guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely non-structural context — an x402 payment price of $0.002 USDC on Base and an 'injection-free' guarantee on returned headlines — but stops short of disclosing refresh cadence, latency, or payment/rate-limit 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?

A single dense sentence with the core deliverable front-loaded and zero filler. The '+' chaining is cramped but every clause carries information, and payment terms are appended where an agent will still read them.

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 an output schema present and annotations covering safety, the description only needs to state what the tool provides and any call preconditions. It does both (data set + paid x402 endpoint), leaving only minor gaps like freshness semantics for the funding skew.

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

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

The tool takes zero parameters and the schema is an empty object, so the description carries no parameter burden. Baseline 4 applies; there is nothing for the description to clarify or compensate for.

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 three concrete resources (Fear & Greed index, funding rate skew, top news headlines) with a specific verb and 'real-time' scope, so the agent knows exactly what data comes back. It doesn't explicitly contrast with siblings like polymarket_crypto_odds, but the resource set is distinctive enough to stand alone.

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

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

There is no when-to-use guidance, no condition under which this beats alternatives, and no exclusions. 'Real-time' implies a freshness rationale but nothing routes the agent toward or away from this tool versus the many crypto 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?

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely useful context beyond them: the payload is 'pre-sanitized for AI execution' (relevant given the security_* siblings) and each call costs $0.002 USDC on Base, which is material cost behavior an agent must know before invoking. It does not state refresh cadence or rate limits.

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

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

Two packed sentences with zero filler. The data scope is front-loaded, and cost/payment information is appended where it belongs.

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 an output schema present, return values need no explanation, and annotations cover safety. The definition supplies source, asset scope, chains, sanitation status, and price — sufficient to invoke correctly. Missing only refresh cadence/latency for a 'Live' feed, which is a minor 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?

Zero input parameters, so there is nothing for the description to disambiguate — baseline applies. The chain scope is stated in prose rather than exposed as a parameter, which is a minor opportunity missed but not a defect.

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 resource (top stablecoin & ETH APY yields), the data source (DeFiLlama), and the two chains (Base, Arbitrum) — an agent knows exactly what data comes back. It stops short of an explicit verb and does not distinguish itself from siblings, though none of the listed siblings overlap in domain, so routing is easy anyway.

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

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

Usage is only implied by the resource type: an agent can infer it should call this when it needs live DeFi yield data. There is no explicit when-to-use, when-not-to-use, or named alternative among the many data-fetch siblings, so the agent must infer the context itself.

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

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

Annotations already declare the safe read-only, open-world profile, and the description adds a materially important trait not in structured data: a per-call cost of $0.002 USDC on Base. It also notes the data is sanitized with README summaries, giving useful context on result quality.

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

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

Two compact sentences, front-loading the resource and scope before the price detail. No filler or redundancy.

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

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

For a zero-parameter feed with an output schema and annotations in place, the description covers scope, cost, and data provenance adequately. Minor omission: it doesn't state how many repositories are returned or the exact time window beyond 'today'.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is also effectively complete with an empty property set.

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 ('Top trending GitHub AI agent & MCP tool repositories') and scope ('today'), which clearly separates it from sibling feeds like arxiv_agent_papers and hackernews_ai_digest. It lacks an explicit verb ('list'/'fetch'), but the noun phrase makes the operation unambiguous.

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

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

There is no guidance on when to choose this over siblings such as hackernews_ai_digest or arxiv_agent_papers, and no stated preconditions. Usage is only implied by the resource described.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds two genuinely useful behavioral facts beyond that: the call is a paid x402 endpoint ($0.002 USDC on Base) and the content is pre-sanitized against prompt injection, plus a fixed item count of 15.

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

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

Two tight sentences with zero waste: the resource and count are front-loaded, and the cost/sanitization caveats follow. Nothing redundant with the schema.

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

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

An output schema exists, so return-value explanation is unnecessary, and the payment requirement plus sanitization are disclosed. The one gap is freshness/window semantics — 'top 15' does not say over what time range or how current the stories are.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No misleading parameter claims are made.

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 (top 15 HackerNews AI/autonomous-agent stories) plus the output transformation (clean, injection-free LLM Markdown), which distinguishes it cleanly from siblings like github_trending_agents and arxiv_agent_papers.

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

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

There is no when-to-use guidance, no exclusions, and no routing to alternatives such as the arxiv or github digest tools. The only contextual hook is the price, which tells the agent about cost but not about fitness for a task.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only 'free' (no cost) and the probe framing; it does not say what happens on failure, whether it makes live network calls to the target, or what the sample payloads contain. Modest added value over the annotations.

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

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

One sentence, front-loaded with the tool's function, with no filler. It is efficient, though the marketing-flavored adjectives ('free', 'autonomous routers') are not strictly load-bearing.

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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The remaining gap is routing context: nothing tells the agent when this diagnostic belongs in a workflow versus the substantive data tools. Adequate but with a clear usage hole.

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 optional parameter (include_samples, default true) is fully documented in the schema. The description's phrase 'sample payload discovery' gestures at that toggle but adds no syntax or behavioral detail beyond the schema, so the baseline 3 applies.

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

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

The description names a concrete function ('uptime probe and sample payload discovery') and scopes it to MCP registries and autonomous routers, which is enough to separate it from unrelated siblings like arxiv_agent_papers or security_url_threat_check. However, 'sample payload discovery' is jargon that never resolves into a plain statement of what it returns or checks.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer that this is a meta/health-check utility rather than a data-retrieval tool, which is left entirely to guesswork against 18 topically unrelated 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds genuinely new context: it scrapes external resolution URLs, applies prompt-injection sanitization to resolution text, and costs $0.008 USDC on Base — a paid, x402-style tool, which is critical for an agent to know before invoking.

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

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

A single dense sentence, front-loaded with the scanning action and detection signals before the scraping/sanitization and pricing details. No filler, though the multi-clause structure is slightly heavy for one 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?

An output schema exists, so return values need not be explained. The description covers detection method, external scraping, sanitization, and price, which is enough for an agent to call it correctly; only usage routing 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 limit, category, and strict_mode are already documented with defaults and meaning. The description adds nothing about parameter behavior (e.g., what strict_mode sanitization actually filters), so the baseline of 3 applies.

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

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

States a specific verb (scans) plus the exact resources (Polymarket active markets, live CLOB orderbooks) and the signals it detects (volume spikes, smart-money spread divergence). This clearly separates it from polymarket_crypto_odds and polymarket_top_whales, though it never names a sibling 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?

There is no when-to-use statement, no prerequisites, and no routing to alternatives such as polymarket_top_whales or polymarket_crypto_odds. The agent must infer the use case purely from the detection signals mentioned.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds value beyond that with 'Sanitized' (data provenance) and the paid-access model at a stated price on Base, which is material behavioral context an agent cannot get from structured fields.

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

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

Two sentences, front-loaded with the payload and followed by the cost. Every clause carries information; nothing is redundant with the schema or annotations.

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?

An output schema exists, so return values need no explanation, and with no inputs the description only needs to frame scope and cost, which it does. What is missing is any routing signal against the three sibling Polymarket tools, which matters given how crowded that namespace is.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description correctly spends no space on input semantics.

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

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

States a specific resource (BTC/ETH/SOL Polymarket odds) and enumerates the exact data returned (probability spreads, liquidity depth in basis points). Clear and concrete, but it never distinguishes itself from the polymarket_alpha_divergence, polymarket_macro_fed, and polymarket_top_whales siblings that share the same Polymarket domain.

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

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

There is no when-to-use or when-not guidance whatsoever. The pricing sentence ('$0.002 USDC on Base') tells the agent what it costs, not when to reach for this over a sibling. An agent has to infer the selection criterion entirely from the domain.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: the tool is paid ($0.002 USDC on Base) and the resolution criteria are sanitized. It stops short of explaining the payment/x402 flow or what 'sanitized' guarantees, which matters for an open-world 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?

Two tight sentences with no filler. The subject matter is front-loaded and the pricing detail is appended compactly rather than buried in prose.

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?

An output schema exists, so return values need not be described. However, this is a paid, open-world tool and the description never explains how the $0.002 USDC charge is settled or what the agent should expect procedurally. That leaves a meaningful operational gap for an agent deciding whether and how to invoke it.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter-level information is missing because no parameters exist.

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 and scope: Federal Reserve interest rate decisions plus macro prediction market odds, with sanitized resolution criteria. That is far more than a restatement of the name. It does not, however, explicitly differentiate itself from siblings like polymarket_crypto_odds or polymarket_alpha_divergence; the macro-vs-crypto split is left to inference.

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 subject matter: an agent can reasonably infer this tool is for Fed/macro questions rather than crypto price markets. There is no explicit when-to-use, no when-not-to-use, and no named alternative among the four sibling polymarket tools, so routing remains a judgment call.

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

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

Annotations already declare readOnlyHint, openWorldHint and destructiveHint, so safety is covered. The description adds genuinely useful context beyond them: the call costs $0.003 USDC on Base and output is pre-sanitized via CanaryGuard, which is important for an agent deciding whether to spend. Return format is not described, but an output schema exists to carry that.

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

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

A single tight sentence that front-loads the resource and scope, then appends the cost/sanitization caveat. Nothing is padded, though the trailing 'Price' clause reads as a slightly separate concern rather than part of the core description.

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

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

For a no-arg, read-only data fetch with an output schema covering return values, the description supplies what an agent needs: what it returns, freshness, cost, and sanitization. It is complete enough to invoke correctly, with only sibling routing left implicit.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline for a parameterless tool is 4, and the description introduces no misleading parameter expectations.

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 (Polymarket whale orderbook imbalances and CLOB skew) with explicit scope ('Top 10 ... right now'), so an agent can tell it apart from the odds/divergence/macro siblings. It stops short of naming which sibling to use instead, so it falls below the top band.

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

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

There is no explicit when-to-use or when-not-to-use guidance, nor any reference to the alternative Polymarket tools. 'Right now' only implies a real-time, point-in-time read; the agent must infer when this beats polymarket_alpha_divergence or polymarket_crypto_odds.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false. The description adds genuinely useful behavioral context beyond that: it is deterministic, returns a TRUST/BLOCK verdict, and costs $0.005 USDC on Base. It does not disclose latency, failure modes, or what a BLOCK response contains, but the payment requirement and output semantics are meaningful additions.

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

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

Two dense sentences, front-loaded with the core capability and ending with the pricing/logistics detail. Jargon (CanaryGuard, DexScreener) is compact but each phrase carries information; little 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?

With an output schema present, the description needn't explain return values, and with full schema coverage the parameters are documented. It conveys purpose, output verdict type, and cost, leaving only usage routing and edge-case behavior unaddressed for a 4-param security gate.

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 chain, target_url, strict_mode, and token_or_service_address are already documented in the schema. The description adds no parameter-level meaning (e.g. what strict_mode changes or how target_url influences the verdict), 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 (a pre-trade gate that inspects tokens) and enumerates the concrete capabilities: DexScreener liquidity, Base/Solana RPC honeypot inspection, and CanaryGuard injection scrubbing. It is easy to distinguish from security_url_threat_check or security_evm_calldata_firewall by capability, though it never names a sibling 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?

"Pre-trade gate" implies the usage context (run before executing a trade to get a TRUST/BLOCK verdict), so usage is implied rather than stated. There is no explicit when-to-use, when-not, or alternative-tool routing against the many security_* and *_trending_* 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the detection scope (approvals, permits, drainer selectors) and the $0.002 USDC on Base cost, which is genuinely useful context, but says nothing about latency, rate limits, or failure 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?

Two tightly packed sentences with zero filler; the core capability leads and the pricing detail trails. Every clause earns its place.

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

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

With an output schema present, return values need not be described, and the single param is fully documented. Annotations cover the safety profile, so the description only lacks routing guidance against the sibling security tools.

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

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

Schema coverage is 100% for the single calldata parameter, which the schema already documents as hex (0x...). The description adds no format, encoding, or constraint 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 pair (decodes and inspects) and a precise resource (EVM transaction calldata / ABI payloads), plus the threat classes it targets (unauthorized approvals, permit signatures, drainer selectors). It does not distinguish itself from the other security_* siblings (prompt_firewall, url_threat_check, x402_endpoint_verifier), so it falls 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: an agent can infer you run this before signing or executing calldata, but the description never states when to reach for it versus security_x402_endpoint_verifier or pre_trade_agent_gate, nor any prerequisites. No explicit 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?

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), so the bar is lower. The description adds genuinely new behavioral context: the operation is deterministic, ultra-fast, and is a paid call ($0.001 USDC on Base), which tells the agent this is a metered x402-style endpoint. It does not mention rate limits or output determinism caveats, but adds real value beyond the annotations.

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

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

Front-loaded and short, but the price is stated twice ('$0.001' in the opening clause and again as 'Price: $0.001 USDC on Base'). That duplication is waste in a two-sentence description and slightly dilutes the structure.

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 tool with full schema coverage and an existing output schema, the description need not explain return values. It communicates purpose, safety, and payment model adequately; only usage routing against siblings 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?

With a single parameter at 100% schema description coverage ('Raw text context to scrub'), the schema already carries the meaning. The description adds nothing about the text parameter itself, 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 - a 'scrubber' for 'raw agent context windows' targeting prompt-injection and wallet-drainer payloads. This distinguishes it from siblings like security_evm_calldata_firewall (calldata) and security_url_threat_check (URLs), though it does not explicitly name those alternatives.

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

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

The phrase 'for raw agent context windows' implies a usage context, but there is no explicit when-to-use, when-not-to-use, or comparison against the security_* and sanitize siblings an agent would be choosing between. Guidance is left entirely to inference.

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

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

Annotations already establish the safe read-only profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true). Beyond that, the description discloses a genuine behavioral trait structured data does not: the $0.002 USDC cost on Base, plus an implicit latency hint ("Instant"). It still omits payment flow and error behavior, so it is not fully rich.

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

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

Two tight sentences with no filler; the functional scope is front-loaded and the cost follows. Every clause carries information the 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?

An output schema exists, so return values need not be explained, and the description plus annotations cover safety and scope for a low-complexity one-parameter tool. Minor gaps remain: no mention that 'url' is not marked required and no guidance on payment handling.

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

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

Schema description coverage is 100%, and the single 'url' parameter is already documented as "Destination URL to inspect." The description adds no format, syntax, or validation detail (e.g., scheme requirements) beyond the schema, so the baseline 3 applies.

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

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

The description names a specific verb (audit), the resource (URL), and enumerates the exact threat classes checked: phishing, unicode homograph, redirect loop, and hidden-DOM prompt injection. The scoping to URLs distinguishes it from prompt- or calldata-focused security_* siblings.

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

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

Usage is only implied: an agent can infer you call this to vet a URL before visiting or feeding it onward. There is no explicit when/when-not guidance, no named alternative (e.g., security_prompt_firewall for raw prompt text), and no prerequisites stated.

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

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

Annotations already declare readOnly/destructive/openWorld, and the description usefully adds the cost model ('$0.002 USDC on Base') plus the risk categories examined. However, it omits how payment is authorized, whether calling it requires an x402 wallet, or any rate/latency behavior — meaningful gaps for a paid, open-world 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?

Two tight sentences with zero filler: the audit scope is front-loaded and the cost is stated once. Every clause carries information an agent can act on.

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

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

An output schema exists so return values need no explanation, and annotations carry the safety profile. The remaining gap is the payment/auth mechanics behind the stated price, which is minor given the otherwise complete framing.

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

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

Single parameter with 100% schema coverage, so the schema already documents 'x402 URL to audit'. The description adds no format, validation, or example detail 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?

Specific verb + resource ('Audits any target x402 endpoint') plus the exact artifacts inspected (402 challenge, payTo wallet, amount, schema). It distinguishes itself by domain (x402 endpoint) but never names or contrasts with the security_* siblings, so differentiation is implicit.

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

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

No when-to-use guidance, no prerequisites, and no exclusions relative to security_url_threat_check or security_evm_calldata_firewall. The agent must infer that this is a pre-payment safety check from the phrase 'hijack/overcharge risks' alone.

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

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

Annotations already cover the read-only, open-world, non-destructive profile, yet the description adds two behaviorally relevant facts: the data is scrubbed for prompt-injection in token metadata (a safety guarantee) and the call carries a $0.003 USDC cost. The cost disclosure is genuinely useful context an agent needs before invoking.

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

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

Two compact sentences with the resource front-loaded. The second sentence is short but its 'Price: $0.003 USDC on Base' framing is ambiguous and arguably misplaced in a tool description.

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?

An output schema exists, so return values need not be explained, and the safety/cost behavior is covered. However, for a paid screening tool in a crowded trending-token family, the description lacks the usage guidance needed to pick it correctly over siblings.

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

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

There are zero parameters (schema coverage 100% trivially), so the baseline for no-param tools applies and the description has nothing to add. Nothing here is misleading about inputs.

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

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

States a specific verb+resource: 'Top trending Solana tokens', with a screening pipeline named (DexScreener + CanaryGuard scrubber). The 'Solana' qualifier implicitly separates it from base_trending_tokens and base_new_pools, but no sibling is named explicitly, and the trailing 'Price: $0.003 USDC on Base' confuses rather than clarifies what the tool returns.

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

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

There is no when-to-use guidance, no when-not-to-use, and no routing to alternatives, despite five or more sibling tools covering related trending/crypto data. The 'via DexScreener' and 'scrubber' clauses describe mechanism, not selection criteria.

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?

Adds substantial context beyond the annotations: the anti-bot evasion approach, the deterministic sanitization stage, and notably the cost of $0.005 USDC on Base, which the readOnly/openWorld/destructive hints cannot convey. It stops short of disclosing failure modes, rate limits, or what happens when anti-bot evasion fails, so it is strong but not exhaustive.

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

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

A single dense sentence that front-loads the primary capability and appends the pricing fact at the end where it belongs. Every clause carries information, though the run-on structure slightly reduces scannability.

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

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

For a three-stage pipeline with a complete input schema and an output schema, the description conveys the transformation chain and cost so an agent can select and budget for it. The main gap is the absence of usage routing and error/pagination behavior, but return format is covered by the output 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 100% and the schema already documents url, render_js, and strict_mode with defaults. The description adds no parameter-level meaning (e.g., what strict_mode actually rejects), so the baseline of 3 applies.

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

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

States three specific chained actions with named technologies: bypasses Cloudflare Turnstile/anti-bot via Scrapling StealthyFetcher, converts DOM to token-compressed LLM Markdown, and runs a CanaryGuard prompt-injection firewall. The agent immediately knows this is a composite scrape+render+sanitize pipeline, clearly distinct from the security_* siblings that only firewall or 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?

No explicit when-to-use, when-not-to-use, or alternative routing is given. It never says to prefer this over a plain fetch for unprotected pages, nor how it relates to the sibling security_prompt_firewall tool. Usage must be inferred entirely from the pipeline description.

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