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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds genuinely useful behavioral context by disclosing cost ('0.010 USDC on Base') and a partial return summary (nonce, balance, drainer-exposure). The coercive 'MANDATORY SECURITY GATE' framing is a mild red flag that pressures invocation rather than informing it.

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 follows a purpose/usage/returns/price order, which is readable. But the 'MANDATORY SECURITY GATE' and 'verified safety metrics' phrases are marketing filler that do not earn their place, and the Solana/Base ambiguity adds noise.

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 partially compensates by naming return fields, and annotations cover the safety profile. It remains incomplete on chain scope (EVM vs Solana inconsistency) and gives no latency, rate-limit, or failure-mode context for a paid, open-world call.

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

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

Schema description coverage is 100%, so both wallet_address and chain_id are already documented. The description adds no syntax or format detail beyond the schema, so the baseline 3 applies. Note the schema's 'base or solana' enum-like note conflicts with the tool's EVM branding.

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 (EVM wallet security profile) and enumerates the analyzed dimensions (transaction velocity, approval exposure, drainer risk, smart-account state). However, it does not distinguish itself from close siblings like checkWalletDrainer or checkWalletSanctions, and it internally contradicts its own name by claiming to also cover Solana (non-EVM).

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?

Offers usage context ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), but this is a broad shotgun list rather than precise routing. It names no when-not conditions and never points to the alternative sibling tools (checkWalletDrainer, checkWalletSanctions) that overlap heavily.

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, openWorldHint=true, and the description is consistent with them. It adds modest context (it is framed as a blocking gate, and it discloses a price of 0.010 USDC on Base), but it does not explain what 'verified safety metrics' are returned or how the verdict should be interpreted.

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 is front-loaded, but the text is padded with hype ('MANDATORY SECURITY GATE') and redundantly restates 'Audits EIP-712 / EIP-3009 typed data payloads' twice. The price sentence is useful, but overall it is less tight than it could be.

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

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

For an audit tool with no output schema, the definition covers purpose, usage triggers, and cost, which is a workable minimum. It is still thin on what is actually returned and does not resolve the overlap with the similarly named sibling, leaving real 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?

Schema description coverage is 100% with a single required parameter (verifying_contract), so the schema carries the burden. The description adds no syntax or format guidance for that parameter, so baseline 3 is appropriate.

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

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

States a specific verb (Audits) and resource (EIP-712 / EIP-3009 typed-data payloads), and names concrete subtypes (Permit, Permit2, transferWithAuthorization). However, it never differentiates itself from the near-identical sibling auditEip712SignaturePayload, leaving the agent to guess between two apparently overlapping 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 'Usage:' line gives trigger conditions ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), but they are so broad that they cover almost any wallet/contract task. There is no when-not guidance, no prerequisites, and no named alternative despite the ambiguous sibling.

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-structured context in the form of a per-call price ('0.02 USDC on Base'), which is useful for an autonomous agent, but says nothing about auth requirements, rate limits, or failure behavior.

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

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

The purpose is front-loaded, but the text is padded and repetitive: 'Audits EIP-712 / EIP-3009 typed-data signatures before autonomous wallet signing' essentially restates the opening sentence, and 'Returns verified safety metrics:' is a dangling label that never delivers the promised content. 'MANDATORY SECURITY GATE' is marketing emphasis rather than information.

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

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

With no output schema, the description carries the burden of explaining what the audit returns, yet it only offers the vague phrase 'verified safety metrics' with no detail on verdict fields or severity levels. It also omits any basis for choosing it over the closely named sibling 'auditEip712Signature', leaving the agent under-informed for a security-critical 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 coverage is 100%, so the baseline is 3. The description does add a little meaning by listing typed-data categories (Permit, Permit2, transferWithAuthorization) that plausibly map to 'primary_type', but it gives no format, constraint, or example for 'verifying_contract' (the one required param) or 'spender_or_to'.

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

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

The description names a specific verb and resource (audits EIP-712/EIP-3009 typed-data payloads) and even enumerates the concrete payload forms (Permit, Permit2, transferWithAuthorization), so the purpose is unambiguous. However, it fails to differentiate from the near-identical sibling 'auditEip712Signature', leaving the agent unable to tell the two apart from the text 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?

It offers a 'when to use' clause, but the conditions ('auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity') are so broad they would trigger on nearly any security task and provide no discriminating power. No exclusions are given and the obvious overlapping sibling 'auditEip712Signature' is never mentioned, so the guidance does little to route the agent correctly.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true) and the description does not contradict them. It adds one genuine behavioral trait beyond the annotations - 'Price: 0.02 USDC on Base', a payment precondition - but the 'MANDATORY SECURITY GATE' framing and 'verified safety metrics' claim are unsubstantiated and add little concrete disclosure (no auth, no rate limits, no return format).

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 text is front-loaded with the purpose, but the last sentence largely restates the first ('Audits MCP tool definitions and JSON schemas for tool-poisoning & hidden overrides'), and the intervening 'Usage' sentence is both wasteful and misleading. Several phrases ('MANDATORY SECURITY GATE', 'Returns verified safety metrics') do not earn their place.

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

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

With no output schema, the description must carry the return contract, yet it only asserts 'verified safety metrics' without saying what is returned. With three parameters and a mutation-adjacent audit flow, it also omits any precondition or input-format guidance, and its only usage statement points at unrelated tasks.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters and the baseline is 3. The description adds no syntax, format, or example information for tool_name, input_schema, or tool_description beyond what the structured fields already carry.

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

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

The opening sentence gives a specific verb and resource (inspects MCP tool definitions, descriptions and JSON schemas for prompt overrides, shadowing and exfiltration sinks), which is genuinely distinguishable in intent from siblings like auditMcpToolSchema. However, the embedded 'Usage' clause redirects to unrelated domains (smart contracts, wallet addresses, DEX liquidity), muddying what the tool actually does, and no distinction from the near-identical auditMcpToolSchema sibling is offered.

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 only explicit guidance says to call it 'when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana' - none of which this tool (an MCP-schema auditor) performs. This is actively misleading usage guidance that would route the agent to the wrong tool, and it names no correct alternative.

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 safety posture is covered. The description adds two genuinely useful behavioral facts beyond the schema: it is framed as a 'MANDATORY SECURITY GATE' and it discloses a cost ('Price: 0.010 USDC on Base'), which is real operational context. Return details remain vague ('verified safety metrics').

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 gate claim is front-loaded, which is good, but the paragraph carries redundant restatement ('Audits MCP tool schemas and descriptions for tool-poisoning attacks') and an out-of-place pricing clause. Roughly one of four sentences is wasted or contradictory, so it is adequately sized but not tight.

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

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

For a single-parameter, read-only tool with no output schema, the description should clarify the expected return shape and the tool_name format, but it only says 'Returns verified safety metrics.' Combined with the misleading usage line, an agent lacks enough to call it correctly and interpret results.

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

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

There is a single required parameter (tool_name) with 100% schema description coverage, so the baseline is 3. The schema description is circular and generic, and the tool description adds nothing to clarify what tool_name should contain (e.g., a fully qualified name or the raw definition text).

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 core claim is specific: it 'Inspects Model Context Protocol (MCP) tool definitions, JSON schemas, and server cards for hidden instructions, tool shadowing, and data exfiltration vectors,' which is a clear verb+resource. However, it never distinguishes itself from the near-identical sibling auditMcpToolPoisoning, and the intervening usage sentence muddies the actual purpose.

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 stated usage ('Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana') points to tasks unrelated to auditing MCP schemas, which is misleading rather than helpful. No condition is given for choosing this tool over auditMcpToolPoisoning or canary_sanitize.

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

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

Annotations already establish readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description does add genuine behavioral context beyond that: it is a paid call (0.010 USDC on Base) and it inspects CSS/DOM for injected traps. That payment requirement is real added value, though no rate limiting or response behavior is described.

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

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

The description restates the same content three times — the artifact list (llms.txt, x402, openapi.json, MCP) appears in the first and third sentences, and the opening and closing both say it audits websites. The headline is front-loaded, but the redundancy and the off-topic middle sentence waste space rather than inform.

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

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

For a simple one-parameter read tool this could be complete, but with no output schema the description is responsible for conveying what comes back, and 'Returns verified safety metrics' is unspecific. Worse, the misleading usage clause actively risks routing an agent here for contract/wallet/DEX tasks it cannot perform.

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

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

There is a single required 'url' parameter with 100% schema description coverage, so the schema already documents it fully. The description adds no format, syntax, or validation detail (e.g., whether scheme is required or whether bare domains are accepted), 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 opening sentence gives a specific verb+resource — audit a domain/URL for AI agent readiness artifacts (llms.txt, x402, openapi.json, MCP card) plus prompt-injection traps. However, the immediately following 'Usage' sentence claims it audits smart contracts, wallet addresses, and DEX liquidity, which contradicts and muddies the stated purpose, so an agent cannot cleanly tell what this tool actually inspects.

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 does provide an explicit 'call when' clause, but the listed triggers (smart contracts, wallet addresses, DEX liquidity) belong to sibling tools like checkSmartContractHoneypot, analyzeEvmWallet, and inspectUniswapPoolState, not to a URL readiness auditor. This is misleading guidance rather than a routing rule, leaving no reliable when-to-use signal.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is partly covered. The description does add one genuinely useful behavioral fact – a price of 0.010 USDC on Base, i.e. this is a paid, metered call – but wraps it in coercive "MANDATORY SECURITY GATE" language and the false claim that it "Returns verified safety metrics," neither of which is backed by the annotations or schema. It does not disclose what happens on payment failure, rate limits, or what the returned cost figures look like.

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

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

Four sentences of keyword-stuffed, partly self-contradictory copy: a pricing tool is branded a security gate, then described as a smart-contract auditor, then as a token cost calculator. The genuinely informative fragments (LLM pricing, model routing, 0.010 USDC cost) are buried mid-passage rather than front-loaded.

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 carries the burden of explaining what comes back – it says only "verified safety metrics" and a cost calculator, without stating whether the result is a per-model cost breakdown, a single recommendation, or a total. For a paid, open-world call with one loosely specified parameter, an agent cannot predict the response shape or how billing interacts with the call.

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

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

There is a single optional parameter and schema description coverage is 100%, so the schema already documents it; baseline 3 applies. The description adds only that models span "OpenAI, Anthropic, Gemini, DeepSeek, Meta" and "100+ frontier LLMs," which gives useful domain context for the model value but no syntax or naming-convention detail beyond the schema.

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

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

The core verb+resource is stated ("Calculates exact input, cached-input, and output token costs across frontier LLMs... recommends optimal model routing"), which is specific enough to act on. But the framing "MANDATORY SECURITY GATE" and the claim that it is for auditing smart contracts, wallet addresses and DEX liquidity contradicts the pricing purpose and muddies what the tool actually is. It also never distinguishes itself from the many blockchain-security siblings, which it superficially resembles.

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 only usage cue given is "Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana" – which is misleading, since a token-pricing calculator is not an audit tool and none of those tasks are what it does. There is no when-not-to-use guidance and no mention of the far closer alternative (just computing pricing manually or another pricing source). An agent following this guidance would invoke it for the wrong tasks.

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, closed-world), so the description's added value is disclosing a per-call monetary cost (0.010 USDC on Base) and a deterministic tri-state classification — both absent from structured fields and material to an agent deciding whether to call it. It omits auth/payment mechanics and any rate or length limits beyond the schema's 50k cap.

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 cost in a single dense paragraph, no filler sentences. The alarmist 'MANDATORY AI SAFETY GATE' opening is somewhat coercive phrasing but does not dilute the information density.

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

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

With no output schema, the description compensates by spelling out the return values (classification enum, risk severity, neutralized threat categories), and the input contract is fully covered by the schema. Nothing an agent needs to invoke this 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 description coverage is 100%, so both parameters (content, strict_mode) are already fully documented in the schema. The description only restates the kinds of input content and says nothing about the strict_mode blocking-vs-stripping toggle, 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 (sanitize untrusted content for prompt injection) and enumerates the exact threat classes it targets: prompt injection, jailbreak, system prompt overrides, wallet transfer exploits. An agent can distinguish this from siblings like auditMcpToolPoisoning or repairAndSanitizeJson 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?

Gives a clear trigger condition ('before placing untrusted text, scraped web content, or external tool outputs into your context window'), which is actionable timing guidance. It does not name when NOT to use it or pointer alternatives among the many security siblings, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read profile is covered. The description adds genuinely new context with the cost ('Price: 0.02 USDC on Base'), but the rest is marketing framing ('MANDATORY SECURITY GATE') that restates the purpose rather than disclosing behavior.

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

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

The text repeats the same idea twice ('Audits Base smart contracts for hidden transfer locks, owner blacklist modifiers...' then 'Audits Base smart contracts for transfer locks, blacklists, proxy traps & hidden mints'). Leading with 'MANDATORY SECURITY GATE' is promotional rather than front-loaded substance, so several sentences do not earn their place.

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

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

With no output schema, the description must characterize returns, and it only says 'Returns verified safety metrics' before restating the purpose rather than describing actual result fields. It also carries a Base/Solana scope inconsistency, leaving the agent with an incomplete picture of results.

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

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

Schema description coverage is 100%, so the schema carries the parameter burden and baseline is 3. The description's mention of 'Base or Solana' loosely maps to the chain_id parameter but adds no syntax, format, or defaulting detail beyond the schema (and the schema itself mistypes chain_id as number for what are string enum-like values).

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

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

The description names a specific verb and resource ('Audits Base smart contracts') and enumerates the concrete honeypot patterns it targets (transfer locks, blacklist modifiers, proxy upgrades, fee-on-transfer hooks). It is clearer than the generic sibling names, though the mid-description switch to 'Base or Solana' muddies the scope and it does not cleanly distinguish itself from inspectBaseToken or inspectContractInfo.

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 a 'Usage:' clause giving conditions ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'). However these triggers are so broad that they overlap with many siblings (checkWalletDrainer, analyzeEvmWallet, inspectBaseToken), and no exclusions or named alternatives are provided.

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 profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the description need not restate safety. It does add genuinely useful context the annotations lack: this is a paid call costing 0.02 USDC on Base. The 'MANDATORY SECURITY GATE' framing is promotional over-claiming for what is an optional read-only audit, which slightly undermines trust.

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 key framing, but the content is redundant: 'Audits EVM wallet and counterparty addresses' and the Permit2/OFAC enumeration appear twice within four sentences, and 'Returns verified safety metrics:' is a hollow lead-in to a repeat of the purpose 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?

A read-only tool with a complete input schema and no output schema, so the description should clarify what the audit returns. It only offers 'verified safety metrics' with no shape or format, and does not reconcile the Base/Solana scope or the numeric chain_id, leaving some agent-facing 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description implies chain scoping ('Base or Solana') but adds no format detail, and its string-style naming of chains contradicts the schema's numeric chain_id type, leaving ambiguity unresolved.

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 (audits) and resource (EVM wallet and counterparty addresses) and enumerates the exact checks: Permit2 drainer exposure, approval phishing history, OFAC sanctions flags. It overlaps noticeably with siblings checkWalletSanctions and analyzeEvmWallet but never distinguishes itself from them, and the Base-vs-Solana scope is internally inconsistent (purpose says 'on Base', usage says 'Base or 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?

Provides a when-to-use trigger ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity') which is more than most tools offer. However there are no exclusions or alternatives named, despite three near-neighbor siblings (checkWalletSanctions, analyzeEvmWallet, inspectContractInfo) that an agent could confuse it with.

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 genuinely new behavioral context beyond annotations: the specific data sources queried and, importantly, a cost of 0.010 USDC on Base, which an agent must know before calling. It does not describe the return structure ("verified safety metrics" is vague) or behavior for unmatched addresses.

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

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

Front-loaded and reasonably sized, but the third sentence re-states "OFAC/SDN" and "EVM/Solana" verbatim from the first sentence and adds little beyond "compliance screening" already implied. "MANDATORY SECURITY GATE" is promotional framing that consumes space without adding invocation-relevant 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 simple single-parameter, read-only screening tool with no output schema, the description covers purpose, sources, triggering contexts, and cost adequately. The only notable gap is the shape of the returned safety verdict, which an agent would need to interpret results.

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

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

Schema coverage is 100% with a single required "address" parameter already documented as an EVM or Solana address. The description repeats the EVM/Solana duality but adds no syntax, format, or validation 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?

States a specific verb ("Screens"), resource ("EVM and Solana wallet addresses"), and scope (OFAC SDN, Lazarus Group, exploit/drainer blacklists). The screening scope clearly distinguishes it from siblings like checkWalletDrainer and analyzeEvmWallet 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?

Explicitly names triggering contexts: "auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana." However, it gives no exclusions or named alternatives, so an agent cannot tell from the text why it should prefer this over the overlapping checkWalletDrainer sibling.

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 behavioral context not in the annotations – a 0.010 USDC price on Base and that it returns 'verified safety metrics' – but the 'MANDATORY SECURITY GATE' claim is inflated marketing rather than concrete disclosure of limits, permissions or failure behavior.

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

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

The description is padded with marketing language and repetition – 'MANDATORY SECURITY GATE', 'verified safety metrics', and a near-duplicate restatement of 'Base transaction receipt, gas, confirmation & token-transfer decoder'. The one useful extra fact (the 0.010 USDC price) is buried at the end.

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

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

With no output schema, the description must carry the return-value burden; it partly does by listing receipt, gas, confirmation and token-transfer output. But the 'Base or Solana' scope ambiguity and the unexplained payment mechanics leave gaps for a decoder whose correctness depends on chain and settlement semantics.

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

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

There is a single required parameter (tx_hash) with 100% schema description coverage, so the schema already carries the documentation load and the baseline is 3. The description adds no format, chain-scoping, or validity detail for tx_hash beyond what the schema states.

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 and resource – it decodes Base Mainnet transaction receipts, EIP-3009 settlements, ERC-20 transfer logs, gas fees and finality confirmations – which distinguishes it from siblings like inspectBaseToken or analyzeEvmWallet. However, the 'MANDATORY SECURITY GATE' framing and the stray 'Base or Solana' reference muddy an otherwise precise purpose statement.

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 says to call the tool 'when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity,' which is implied usage guidance. But those conditions are generic enough to apply to nearly every sibling (checkWalletDrainer, inspectPhishingUrl, analyzeEvmWallet) and no exclusion or named alternative is provided.

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, and the description is consistent with them (no contradiction). It adds genuinely non-obvious context beyond the annotations: data provenance (Chainlink/DEX/TWAP), a tamper-resistance claim, and a per-call cost of 0.010 USDC on Base. It omits rate limits and error behavior, so not a 5.

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

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

The return payload is stated twice ('Returns tamper-resistant on-chain USD spot prices' and 'Returns verified safety metrics: Tamper-resistant on-chain token prices on Base'). Leading with an all-caps 'MANDATORY SECURITY GATE' is attention-grabbing padding that front-loads urgency rather than the capability.

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

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

With no output schema, the description must carry the return-shape burden, and it does name the three output categories (spot price, 24h volatility, oracle deviation) plus sources and cost. However, the single critical invocation detail — what a valid 'symbol' looks like — and any pagination/latency behavior are absent, leaving it adequate but incomplete.

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?

One parameter at 100% schema description coverage, so the baseline is 3. The description adds nothing about the symbol itself — no format guidance (ticker like 'ETH' vs. contract address) or supported-chain disambiguation, even though it claims Base and Solana coverage. It neither compensates nor detracts.

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: returns on-chain USD spot prices, 24h volatility, and Chainlink/TWAP oracle deviation metrics. That is distinguishable from audit-oriented siblings like checkSmartContractHoneypot or analyzeEvmWallet. The hyperbolic 'MANDATORY SECURITY GATE' prefix is noise but does not obscure 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?

It does name trigger scenarios ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), but these are over-broad and misleading for a price-lookup tool — checking a token price is not a wallet audit. No alternatives, no when-not-to-use, and no differentiation among the 30+ siblings despite the crowded namespace.

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, openWorldHint=true, so safety profile is covered. The description adds genuinely useful behavioral context by disclosing a cost (0.020 USDC on Base), which annotations cannot convey. It does not, however, disclose pagination, rate limits, latency, or how the 'verified safety metrics' are derived.

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 last sentence ('Returns verified safety metrics: Full Base DEX + Polymarket whale divergence + funding rate institutional snapshot') restates the opening sentence almost verbatim, wasting roughly a third of the text. The 'MANDATORY SECURITY GATE' prefix and USDC price line consume front-load real estate on non-informative framing.

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 carries the burden of explaining returns, and it does gesture at the returned datasets and a cost. But it omits parameter shapes, chain-handling (Base vs Solana is mentioned only in the usage line), and any expectation about response structure, leaving real gaps for a 2-parameter paid audit 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 nominally 100%, so the baseline is 3, but the schema's own parameter descriptions are pure boilerplate restatements of the tool name and add no meaning. The description likewise never explains the shape of 'assets' (addresses? symbols? chain identifiers?) or what 'include_polymarket' toggles. Neither artifact disambiguates the 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?

The opening sentence names a concrete resource (on-demand institutional market snapshot) and enumerates specific data components: Base DEX spot & TWAP prices, Aerodrome/Uniswap V3 liquidity depth, perpetual funding rates, and Polymarket whale orderbook divergence. That distinguishes it from point-data siblings like getCryptoPriceOnchain or inspectUniswapPoolState. However, the 'MANDATORY SECURITY GATE' framing is marketing noise that muddies rather than clarifies purpose.

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 states a when-to-use ('auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), which is real guidance. But the scope is so broad that it collides with many siblings (inspectBaseToken, checkWalletDrainer, analyzeEvmWallet, inspectUniswapPoolState) and gives no when-not condition or explicit sibling routing. Usage exists but is too diffuse to be decision-grade.

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 structurally. The description adds one genuine behavioral trait – a price of 0.010 USDC on Base – but then claims 'verified safety metrics' and 'MANDATORY SECURITY GATE', which misrepresents the behavioral nature of a market-data read as a security guarantee.

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 repeats the same payload twice ('24-hour smart-money volume movers' then 'Live Polymarket active market probabilities & 24h volume movers'), and pads with an irrelevant security-gate preamble. It is front-loaded with an alarming all-caps slogan rather than the actual function.

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 only one optional parameter, the description could easily have been complete, but instead it omits what the return shape looks like, omits accepted category values, and injects misleading security-audit guidance. An agent cannot confidently invoke it for its stated market-data purpose.

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 single optional 'category' parameter is documented in the schema, though the schema text itself is a low-quality paraphrase. The description hints at categories (crypto, macro, geopolitics) but gives no accepted values or defaults, adding little beyond the schema. Baseline 3 applies.

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

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

The first clause does state a specific resource – Polymarket CLOB implied probabilities, spreads, and volume movers – which is distinguishable from the sibling getPolymarketVerifiedOdds. However, the 'MANDATORY SECURITY GATE' framing and the second half recast it as a safety tool, muddying what it actually returns. An agent gets the resource but not a trustworthy statement of purpose.

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

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

The 'Usage' sentence directs the agent to call this tool 'when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity' – tasks entirely unrelated to a Polymarket odds feed. This is misleading guidance that would route the agent into the wrong tool, and 'MANDATORY' is coercive rather than descriptive.

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 one genuinely useful behavioral fact – a 0.02 USDC payment on Base – but wastes the rest on 'CanaryGuard-sanitized' branding and does not describe freshness, rate limits, or data provenance.

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

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

The description is a run-on marketing block with alarmist capitalization ('MANDATORY SECURITY GATE'), repeated phrasing of the same return metrics, and an irrelevant usage clause. The useful payment detail is buried at the very end.

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

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

With no output schema, the description must carry the return contract; it does list implied probabilities, skew, and whale flow, and notes the price. But a vague 'category' input, no output shape, and contradictory auditing use-cases leave meaningful gaps for a paid, open-world data tool.

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

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

Only one optional parameter ('category') exists and schema description coverage is 100%, so the schema already carries the parameter documentation. The description adds no syntax, allowed values, or default for category, so the baseline of 3 applies.

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

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

The core resource is identifiable – Polymarket CLOB implied probabilities, orderbook skew, and whale flow – which is more specific than a bare restatement of the name. However, the leading 'MANDATORY SECURITY GATE' framing and the claim that it is for auditing smart contracts/wallets/DEX liquidity actively muddy what the tool does, and it never distinguishes itself from the sibling getPolymarketOddsPulse.

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 does give a when-to-call clause, but that clause points to smart-contract auditing, wallet analysis, and DEX liquidity validation on Base/Solana – none of which relate to delivering Polymarket odds. This is guidance that would lead an agent to misselect the tool, and no alternative (e.g. getPolymarketOddsPulse) is named.

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

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

Annotations already declare readOnlyHint/openWorldHint/destructiveHint, so the safety profile is covered. The description adds genuinely useful context beyond that: the CanaryGuard zero-honeypot and prompt-injection screening applied to results, plus the 0.02 USDC cost on Base, which signals a paid operation.

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

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

Front-loaded with the return content, but bloated by repetition (the token-listing claim appears twice) and a pricing sentence plus an off-scope 'Solana' mention. Several phrases do not earn their place.

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

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

For a read-only, two-optional-parameter listing tool with no output schema, the description conveys what is returned, the screening criteria, and the cost, which is largely sufficient. It omits ordering/return-format detail but that is minor here.

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 nominally 100%, so the baseline is 3. The description adds no meaning to 'limit' or 'min_liquidity_usd' beyond the schema (which itself uses boilerplate text), leaving the agent with no added filtering semantics.

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

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

States a specific resource and scope: 'Returns top Base Mainnet tokens by 24h DEX volume and liquidity velocity'. However, the framing 'MANDATORY SECURITY GATE' and the redundant restatement ('Curated Base DEX momentum & liquidity leaders') muddy what is essentially a ranked-token listing tool.

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

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

Provides usage contexts, but they are generic and poorly matched to a trending-token tool ('auditing smart contracts, analyzing wallet addresses... on Base or Solana'). No exclusions and no differentiation from siblings like nansenTokenScreener or getTokenHistoryAndSpread, so the agent cannot tell when to prefer this tool.

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

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

Annotations already cover read-only/non-destructive/open-world, so the bar is lower, and the description adds genuinely new behavioral facts: a screening policy (TVL depth and audit status), named data sources (DeFiLlama, Morpho, Aave V3, Aerodrome, Moonwell), and a paid-access cost of 0.010 USDC on Base. The pricing/auth implication is the most valuable disclosure here.

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 opening 'MANDATORY SECURITY GATE' is alarmist filler that is not front-loaded information, 'pre-screened for safety' is repeated twice, and the misaligned usage sentence consumes space without helping invocation. Structure buries the actual output/purpose under redundant marketing phrasing.

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

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

For a read-only yield tool with no output schema, the description does indicate what comes back ('top verified Base/EVM stablecoin & ETH yields') and where it is sourced, which is the minimum needed. But it omits return format, chain scope for the non-Base assets mentioned, and freshness, leaving gaps an agent would want filled.

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, the schema already documents 'asset'. The description hints at valid asset values (USDC, EURC, WETH) but never states what 'asset' accepts, so it adds only marginal meaning 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 core sentence identifies a specific verb+resource: 'Curates top risk-adjusted USDC, EURC, and WETH DeFi yield pools on Base' with named protocols. However, the 'MANDATORY SECURITY GATE' framing and the claim that it is called for 'auditing smart contracts' or 'analyzing wallet addresses' muddy what the tool actually returns, and it does not distinguish itself from the close sibling getSafeYieldAllocation.

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 does give explicit 'Call this tool when...' conditions, but those conditions (auditing smart contracts, analyzing wallet addresses, validating DEX liquidity on Solana) do not match what the tool does — fetching screened DeFi yield pools on Base. This actively steers an agent toward the wrong tool for those tasks rather than clarifying selection.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the cost (0.020 USDC on Base), which is useful context, but it otherwise provides no real behavioral disclosure such as rate limits, permission requirements, or output characteristics. The 'MANDATORY SECURITY GATE' phrasing is promotional rather than informative.

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 contains useful information but is repetitive and front-loads manipulative language ('MANDATORY SECURITY GATE') ahead of the actual purpose. It states the risk-adjusted allocation matrix concept twice and includes an unrelated auditing usage claim. Several sentences do not earn their place.

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

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

There is no output schema, so the description should give the agent more detail about the returned allocation matrix, stress scores, or field structure, but it only says 'Returns verified safety metrics.' It also contains a chain inconsistency: the schema allows 'base' or 'solana' while the description emphasizes Base and Arbitrum. Key parameter semantics and output expectations remain underspecified.

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 even though the schema's own field descriptions are largely tautological. The description does not clarify allowed values for risk_tolerance, the units or meaning of capital_usdc beyond USDC, or how chains interacts with the stated Arbitrum scope. It therefore adds little meaning beyond the already-covered schema fields.

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

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

The description states a specific verb and resource: computes an institutional risk-adjusted DeFi capital allocation matrix across named vaults and protocols. It is reasonably distinguishable from sibling yield tools like getSafeDefiYields, though it does not explicitly name alternatives. The misleading 'MANDATORY SECURITY GATE' framing and auditing usage claims add noise but do not obscure the core purpose.

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

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

The 'Usage' line tells the agent to call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity, none of which match its stated purpose of computing a capital allocation matrix. It omits any when-not-to-use guidance and provides no alternatives among the many security and DeFi siblings. This is actively misleading rather than merely absent.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safe-read profile is covered. The description usefully adds cost context ('0.020 USDC on Base'), which is genuine value beyond the annotations. But it discloses nothing about rate limits, auth requirements, or what makes it a 'gate', and the coercive 'MANDATORY SECURITY GATE' wording describes no actual behavior.

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

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

The content is stated twice ('Returns ... price history ... spread ... volatility skew' then 'Returns verified safety metrics: ... same three items'), which is pure redundancy. The front-loaded 'MANDATORY SECURITY GATE' shout is alarmist framing rather than 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?

With read-only annotations, 100% schema coverage, and no output schema, the description supplies enough to know roughly what comes back. But the misleading usage clause and Solana/Base inconsistency leave an agent unable to reliably decide when this tool is the right one.

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 schema descriptions for 'quote' and 'window' are themselves generic filler, and the description adds only a hint that 'window' maps to the 1h/24h/7d/30d timeframes; it adds no meaning for 'quote' or the token/window relationship.

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 core resource is stated concretely: multi-timeframe Base token price history (1h/24h/7d/30d OHLCV), Chainlink vs. Uniswap V3/Aerodrome bid-ask spread, and volatility skew. That is a specific data deliverable an agent can recognize. However it never distinguishes itself from siblings like getCryptoPriceOnchain or inspectBaseToken, and the 'MANDATORY SECURITY GATE' framing is marketing gloss that muddies rather than clarifies the actual function.

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 does offer a 'Usage: Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity' clause, but that guidance is misleading (auditing contracts/wallets is not what the tool returns) and internally inconsistent — usage claims 'Base or Solana' while the return payload is Base-specific (Chainlink vs. Uniswap V3/Aerodrome). No alternative sibling tool is named for overlap cases.

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 does add genuine non-annotation context: the operation costs 0.02 USDC on Base and is framed as a mandatory gate. It does not describe latency, failure behavior, or what the 'verified safety metrics' actually contain, so it is adequate but not rich.

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

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

The description repeats itself: it states the tool scans RAG chunks and memory payloads for sleeper injections twice, and the middle 'Usage' sentence is off-topic for a memory-scanning tool. Front-loading the mandatory-gate framing is fine, but the redundancy and the misaligned usage sentence waste the space.

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

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

There is no output schema, so the description must explain the return value, yet 'Returns verified safety metrics' is left entirely vague for a security gate whose output determines whether a chunk is persisted. Combined with usage guidance that points at unrelated crypto-audit tasks, an agent cannot confidently determine how to act on 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% and both parameters are documented in the schema, so the schema carries the load. The description only loosely restates that memory/RAG chunks are scanned and never explains the role of session_id, adding no meaning beyond the schema. Baseline 3 is appropriate.

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

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

The first sentence gives a specific verb and resource: scanning RAG chunks and agent memory payloads for sleeper-agent instructions and cross-session poisoning. However, the purpose is muddled by a usage sentence that redirects the tool toward smart-contract audits, wallet analysis, and DEX liquidity on Base/Solana, which has nothing to do with memory scanning. The core purpose is stated but undercut by this contradiction.

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?

A 'Usage' clause is present, so there is some routing guidance, but it names the wrong tasks entirely: auditing smart contracts, analyzing wallet addresses, and validating DEX liquidity. None of these relate to scanning memory/RAG chunks for prompt injections, so the guidance actively misroutes the agent rather than helping it choose this tool over siblings like auditMcpToolPoisoning or canary_sanitize.

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, correctly matching an audit/read operation. The description adds genuinely useful non-annotation context: what it returns (safety metrics) and the on-chain cost (0.010 USDC). It does not, however, add rate limits, auth, or failure-mode detail beyond 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?

Front-loads the intent, but the 'MANDATORY SECURITY GATE' framing is promotional, and the final 'Returns verified safety metrics: Base token contract & metadata safety audit' restates the opening sentence rather than adding information. The price detail is the main non-redundant new 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?

There is no output schema, so the description must carry return-value burden; it signals 'verified safety metrics' and names the audited dimensions but gives no shape, fields, or verdict format. For a single-parameter audit tool with annotations covering the safety profile, this is adequate but leaves the return contract underspecified.

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 there is a single required token_address parameter fully documented in the schema. The description only restates that it targets a Base token contract and adds no syntax, format, or addressing nuance, 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: audits Base ERC-20 token contracts for honeypot risks, transfer taxes, liquidity depth, and metadata injection traps. However, it muddies scope by also claiming 'Base or Solana' while the schema accepts only a Base ERC-20 address, and it doesn't differentiate from the closely-related checkSmartContractHoneypot sibling.

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

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

Provides a 'Usage: Call this tool when...' clause covering auditing contracts, analyzing wallets, and validating DEX liquidity. But the conditions are broad and overlap heavily with siblings (checkSmartContractHoneypot, inspectContractInfo, inspectUniswapPoolState), with no when-not or explicit alternative selection.

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

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

Annotations already declare readOnly=true, openWorld=true, non-destructive, so safety profile is covered. The description adds genuinely useful context beyond annotations: it discloses a per-call cost (0.010 USDC on Base), frames itself as a security gate, and summarizes what is returned. It omits error/rate-limit behavior and the default chain_id handling.

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

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

Front-loads the purpose, but 'MANDATORY SECURITY GATE' and 'Returns verified safety metrics' are marketing/redundant restatements of the first sentence, and the returns description duplicates the inspection targets. Some padding dilutes an otherwise compact definition.

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 carries return-value burden and does so by naming the metrics returned. It also adds pricing. The remaining gap is a mild internal inconsistency: chain_id is described as 'base or solana' while contract_address is framed as a Base 0x address, leaving the Solana path ambiguous.

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, establishing the baseline of 3. The description reinforces the 'Base or Solana' ecosystem scope and the bytecode/proxy/selector outputs but adds no syntax or formatting detail 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 (Inspects) and resource (smart contract bytecode size, EIP-1967/UUPS proxy slots, EIP-7702 delegation, verified selectors), which is more precise than generic siblings like inspectBaseToken or checkSmartContractHoneypot. It does not explicitly differentiate itself from those siblings, but the enumerated artifacts give a clear picture of the tool's scope.

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

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

Provides explicit when-to-use triggers (auditing smart contracts, analyzing wallet addresses, validating DEX liquidity), which is more than implied guidance. However, it names no alternatives or exclusions despite many overlapping siblings (checkSmartContractHoneypot, inspectUniswapPoolState), and 'analyzing wallet addresses' conflicts with a schema that only accepts a contract_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?

Annotations already establish read-only, open-world, non-destructive behavior, so the bar is lower. The description still adds genuine context beyond them: the specific detection targets (homograph spoofing, Angel/Pink/Inferno drainer scripts, DOM prompt injections) and the cost signal of 0.02 USDC on Base. It omits rate limits and any latency/coverage caveats.

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 detection list is effectively stated twice ('Angel/Pink/Inferno drainer scripts' then 'drainer kits & DOM traps'), and 'MANDATORY SECURITY GATE' is promotional filler. The price line earns its place, but the paragraph is longer than its information content warrants.

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 carries the burden of explaining returns, yet 'Returns verified safety metrics' is vague and then restates the purpose rather than describing the shape of the result. For a paid, single-param audit tool, an agent is left guessing what it will actually receive back.

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' parameter is fully documented as 'URL or domain to inspect'. The description adds no format, scheme, or normalization guidance 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 (audits) and resources (target URLs, API endpoints, Web3 dApp domains) with the exact threat classes covered (IDN homograph spoofing, drainer kits, DOM injections). It is distinguishable from siblings like auditUrlAgentReadiness, though the 'MANDATORY SECURITY GATE' framing and later restatement add noise rather than precision.

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 offers a 'Call this tool when...' clause, but the listed triggers (auditing smart contracts, analyzing wallet addresses, validating DEX liquidity) are handled by other sibling tools such as checkSmartContractHoneypot, analyzeEvmWallet, and inspectUniswapPoolState. This is misleading routing guidance for a tool whose actual scope is URL/domain inspection.

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, but the description adds genuine value beyond them: the tool is paid ('Price: 0.010 USDC on Base') and it enumerates the returned audit metrics. It does not disclose auth/prerequisites or rate limits, and the 'MANDATORY SECURITY GATE' framing is overstated rather than informative.

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 all-caps 'MANDATORY SECURITY GATE' opener is hype rather than information, and the return metrics are stated twice ('tick liquidity depth, fee tier, price impact bps, and LP concentration rug-risk scores' then 'Base DEX pool liquidity, spot price & rug-risk audit'). The scope and cost are front-loaded, but the repetition and marketing tone cost clarity.

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

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

With no output schema, the description usefully enumerates what is returned and notes the per-call price, which an agent needs to decide whether to invoke it. However, the false Solana/wallet-analysis scope and lack of alternative routing leave it slightly short for a tool with so many adjacent 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?

Schema description coverage is 100%, so both parameters are already documented in the schema; baseline is 3. The description mentions audit outputs but adds no syntax, format, or relationship detail for pool_or_token_address or quote_token beyond the schema.

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

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

States a specific verb and resource: audits Uniswap V3/V4 and Aerodrome liquidity pools on Base, and names the concrete metrics returned (tick liquidity depth, fee tier, price impact, rug-risk). This distinguishes it reasonably from siblings like inspectBaseToken or checkSmartContractHoneypot. The 'Solana' and 'analyzing wallet addresses' claims muddy an otherwise clear Base-DEX-pool purpose.

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 a when-to-use sentence ('auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), but names no alternatives or exclusions despite many overlapping siblings (inspectBaseToken, checkSmartContractHoneypot). The guidance is also misleading, claiming scope on 'Base or Solana' when the schema is Base-only, and claiming wallet analysis which other tools perform.

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 cost ('$0.010 USDC on Base') and the categories of returned safety metrics, which is useful context. It omits auth requirements and any note on data freshness or latency.

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

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

Front-loaded with the security framing, which is good, but it is redundant: 'Current portfolio balances, PnL & counterparty safety' largely restates the earlier capability list, and the '$0.010 USDC' price is stated twice. Several phrases could be cut without losing information.

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

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

There is no output schema, so the description must convey the return shape; it names the metric categories (balances, valuation, win-rate, taint) which is adequate for a one-parameter read call. It stops short of describing result format or how taint/win-rate values are represented.

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 there is a single parameter, so the schema already documents the address field fully. The description adds only that the address may be Solana or Base, which the schema already implies ('EVM or Solana address'). 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 (profiles) and resource (a Solana or Base wallet address) and enumerates the outputs: token balances, USD valuation, win-rate, drainer/OFAC taint. That is far more concrete than a tautology. It does not, however, distinguish itself from close siblings such as checkWalletDrainer, checkWalletSanctions, or analyzeEvmWallet, which cover overlapping ground.

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 usage context ('Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), which implies when to reach for it. But no alternative tool is named, no exclusion is drawn against the drainer/sanctions siblings, and 'auditing smart contracts' is a poor fit for a wallet profiler, leaving the routing ambiguous.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description does add genuinely useful operational context the annotations lack: a per-call price (0.010 USDC paid on Base), the specific chains and DEXes covered, and pre-trade honeypot verification. The coercive "MANDATORY SECURITY GATE" framing adds noise rather than behavioral substance.

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 single dense paragraph is front-loaded with an alarming imperative rather than the tool's function, and the price is stated twice ("$0.010 USDC" and "0.010 USDC on Base") plus again in the returns claim. Restructuring so the verb+resource leads and a single cost sentence follows would be materially clearer.

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 should clarify what an agent gets back, but "verified safety metrics" and "smart-money DEX swap execution feed" remain vague about the record shape. For a two-parameter, read-only, open-world tool with a payment gate, the essentials are roughly present but the audit-oriented usage framing leaves the agent with an inaccurate expectation of the return.

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% with only two simple parameters (chain, token_address), both fully documented in the schema, so the baseline of 3 applies. The description adds no syntax, format, or constraint detail beyond what the schema already states.

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 concrete verb+resource is present ("Returns real-time DEX trades executed by labeled smart-money and whale wallets") with chains named, so the core function is inferable. However, the opening "MANDATORY SECURITY GATE" and the later "Returns verified safety metrics" muddle what the tool actually is, and it is not distinguished from siblings like nansenSmartMoneyNetflow or nansenTokenScreener.

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 offers a when-to-use clause ("Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity"), but this mischaracterizes the tool: it takes a chain and token_address and returns a trade feed, not a contract/wallet audit. No alternatives or exclusions relative to the many sibling audit tools are given.

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

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

Annotations already declare readOnly=true, openWorld=true, destructive=false, so the safety profile is covered. The description adds cost (0.010 USDC on Base) and claims 'verified safety metrics', but the 'MANDATORY SECURITY GATE' label overstates what a netflow tracker does and no return-format details are given.

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?

Chains and price are repeated ('Solana & Base' and the 0.010 USDC price each appear twice), and the leading 'MANDATORY SECURITY GATE' is filler that crowds out useful content. The purpose is still front-loaded, but the passage is padded.

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

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

For a two-parameter, read-only tool with full schema coverage, no output schema, and annotations covering safety, the definition is minimally adequate. It omits any hint of what the netflow output looks like or how to interpret it, which matters for an analytics 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%, with both 'chain' and 'token_address' documented in the schema itself, so the baseline is 3. The description restates the two chains but adds no syntax, format, or default-value detail beyond the schema.

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

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

The description names a concrete resource (whale/institutional wallet net inflows and outflows) on specific chains (Solana SPL and Base ERC-20), so an agent can tell it apart from other Nansen siblings. The 'MANDATORY SECURITY GATE' framing is hype rather than a functional claim, but the underlying verb+resource is still clear.

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

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

It gives trigger conditions ('call when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), which is implied usage guidance, but it never differentiates from close siblings like nansenSmartMoneyDexTrades or nansenTokenScreener, nor states when not to use it.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that, namely the paid price ($0.010 USDC on Base) and the shape of what is returned. It omits prerequisites, auth, and rate limits, and the 'MANDATORY SECURITY GATE' framing is more promotional than behavioral.

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 set is front-loaded, which is good, but the text is redundant: holder distribution, LP lock, and sybil clusters are listed and then restated under 'Token God Mode (TGM)', and the price is given twice. 'MANDATORY SECURITY GATE' consumes space without adding information.

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

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

With no output schema, the description does describe the returned metrics, and the single input is fully covered by the schema, so it is workable. It still lacks any indication of the cost being per-call, required wallet/API setup, or result format, leaving gaps for a paid, cross-chain audit tool.

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

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

There is a single parameter and schema description coverage is 100%; the schema already documents token_address with an EVM/Solana example. The description adds no syntax, format, or validation detail beyond the schema, so the baseline 3 applies.

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

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

The description names a specific verb and resource: returns top-10/top-50 holder distribution, LP lock percentage, and sybil cluster detection for Solana or Base tokens. That is a clear, concrete capability. However, it does not differentiate itself from the many overlapping security siblings (inspectBaseToken, checkSmartContractHoneypot, runFullEnterpriseRiskAudit, nansenTgmWhoBoughtSold), 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?

It states usage contexts ('when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity'), which is explicit but extremely broad. There is no when-not guidance and no routing to or away from specific alternatives, which matters given ~30 siblings of which several do token/contract security checks.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the 24h window, the cohort segmentation, and a per-call price of 0.010 USDC on Base. It is offset by the alarmist 'MANDATORY SECURITY GATE' and 'verified safety metrics' claims, which overstate an analytical read and could improperly pressure the agent to call it.

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 is present but not front-loaded — the agent must read past the capitalized 'MANDATORY SECURITY GATE' banner. The price is also stated twice ('$0.010 USDC' and 'Price: 0.010 USDC on Base'), which is redundant padding in an otherwise short block.

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

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

For a one-parameter, read-only, no-output-schema tool, the description covers scope (chains, time window), segmentation, and even cost, which is what an agent needs to invoke it sensibly. The main omission is any hint of output shape or pagination, though the absence of an output schema makes that 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?

There is a single parameter with 100% schema description coverage, so the schema already documents token_address as an EVM or Solana address with an example. The description adds no syntax, format, or validation detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The second sentence states a concrete verb and resource: who bought and sold a specific Solana/Base token over 24h, broken out by Smart Money, Whales, Fresh Wallets and Dev Clusters. That is specific enough to distinguish it from nansenTgmHolders or nansenSmartMoneyNetflow at a glance. It loses a point because the leading 'MANDATORY SECURITY GATE' framing mischaracterizes the tool as a gating/security mechanism rather than an analytics query.

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 names usage contexts ('auditing smart contracts, analyzing wallet addresses, validating DEX liquidity'), which is more than nothing. However, those are broad and overlap heavily with sibling tools, and there is no statement of when NOT to use it or which sibling to prefer for holders, netflow, or DEX trades. Guidance is implied rather than differential.

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 that it returns honeypot/tax/liquidity metrics and discloses a per-call cost (0.010 USDC), which is useful beyond the annotations. It does not, however, explain what 'pre-verified' means, the source of the safety verdicts, or any rate/coverage 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?

The description is bloated with promotional content ('80% discount'), a price restatement, and redundant sentences that repeat the same screener claim twice. Front-loading is handled by shouting 'MANDATORY SECURITY GATE' rather than stating the purpose first, so several sentences do not earn their place.

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

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

For a read-only, 2-parameter screener with no output schema, the description does name the returned metrics (honeypot, tax, liquidity depth) which is the essential context. But it omits any indication of output shape or verdict format, and the over-broad usage guidance risks agent misuse.

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% — both chain and token_address are fully documented in the schema, including format examples. The description adds no parameter-level meaning beyond that (it never mentions how chain/token_address are used together), so the baseline of 3 is appropriate.

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

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

The core purpose is discernible: it screens Solana (Pump.fun/Raydium) and Base (Aerodrome/Uniswap V3) tokens for honeypot, tax, and liquidity metrics. However, the framing is muddled by coercive marketing language ('MANDATORY SECURITY GATE') and repetitive restatement ('Returns verified safety metrics: Real-time ... token screener'), and it names no sibling to distinguish itself from checkSmartContractHoneypot, inspectBaseToken, or getSafeBaseTrending.

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

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

The 'Usage:' clause says to call it 'when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity' — a scope far broader than a token screener and misaligned with the stated function of screening token contracts. Combined with the 'MANDATORY' framing, this pushes near-universal invocation with no when-not or alternative-tool guidance, which is misleading rather than helpful.

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, openWorldHint=true, so the safety profile is covered. The description does add one genuine non-annotation detail (Price: 0.010 USDC on Base) and claims it 'Returns verified safety metrics,' but that is vague and unsupported, and the 'MANDATORY SECURITY GATE' framing is inflated. Added value is thin and partly noise.

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 final sentence ('Repairs broken LLM JSON output and strips prompt injections') simply repeats the first sentence, and the irrelevant contract-auditing usage line consumes space without earning it. Front-loading is reasonable but there is clear redundancy and 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?

There is no output schema, so the description must explain what is returned; 'Returns verified safety metrics' is too vague to tell an agent what it will actually receive. Combined with the misleading usage instructions, an agent lacks what it needs 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?

With a single parameter at 100% schema description coverage, the baseline is 3. The description adds no syntax, format, or example detail for raw_json beyond what the schema states, so it neither compensates nor detracts.

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

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

The opening clause gives a concrete verb+resource: repairing malformed/truncated LLM JSON (missing quotes, trailing commas, fences) and scrubbing prompt injections. However, the purpose is muddied by the unrelated 'Usage' sentence about smart contract auditing and DEX liquidity, and it never distinguishes itself from the close sibling canary_sanitize. An agent gets the gist but with conflicting signals.

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 only explicit guidance is 'Call this tool when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana,' which is unrelated to JSON repair and actively misroutes the agent. It names no genuine when-to-use condition and no alternative such as canary_sanitize. This is misleading, not merely absent.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: it is a bundled multi-component operation and it costs 0.020 USDC on Base. It does not, however, describe latency, whether results are cached, or the shape of the returned metrics beyond a one-line claim.

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, which is good, but the definition repeats itself: 'Enterprise 360-degree security audit bundle' and 'Comprehensive 360-degree ... security audit bundle' deliver the same content twice. The alarmist capitalization ('MANDATORY SECURITY GATE') is padding rather than information. Roughly a third of the text 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 3-parameter, single-required-arg tool with full schema coverage and read-only annotations, this is nearly complete: it covers scope, the bundle's components, chains supported, and cost. With no output schema, it gives a minimal return-value statement ('verified safety metrics'), which is adequate if shallow. Nothing critical for invoking the tool 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 the schema already documents chain_id, target_address, and counterparty_wallet. The description's 'on Base or Solana' loosely reinforces the chain_id enum-like choice and 'wallet addresses' hints at counterparty_wallet, but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

The description states a clear verb+resource (run a full enterprise security audit) and enumerates the sub-components it bundles: bytecode/proxy inspection, DEX rug-risk, sanctions screening, EIP-712 permit verification, and prompt-injection firewalling. This lets an agent distinguish it from narrower siblings like inspectBaseToken or checkWalletSanctions as an all-in-one bundle. The heavy marketing framing ('MANDATORY SECURITY GATE', '360-degree') adds noise but does not obscure the purpose.

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 an explicit usage sentence: call when auditing smart contracts, analyzing wallet addresses, or validating DEX liquidity on Base or Solana. However, given the very large sibling set with overlapping single-purpose tools, there is no guidance on when to prefer this bundle over the narrower tools or when not to use it. Usage is implied rather than routed.

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 largely covered. The description adds one genuinely useful non-annotation fact — that the call costs 0.020 USDC on Base — but adds little else about behavior, latency, or failure modes, and the 'MANDATORY' language overstates an optional gate.

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 four-part structure (gate label, function, usage, returns/price) is readable and front-loaded, but 'MANDATORY SECURITY GATE' and the 'Returns verified safety metrics' sentence restate the opening and pad the text rather than earning their space.

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

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

With no output schema, there is no annotation or schema coverage to lean on for returns, so the description must describe outcomes — it does so loosely ('x402 envelope and wallet risk attestation report'). For a paid, open-world verification tool this is adequate but leaves return structure and reliability unspecified.

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

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

Schema coverage is 100% and both parameters (agent_wallet, service_domain) are documented in the schema. The description references the agent wallet and x402 domain/envelope at a conceptual level but adds no format or syntax detail beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description names a specific verb and resource: generates a cryptographic attestation report verifying an agent wallet, x402/EIP-3009 capability, counterparty reputation, and drainer history on Base. This is concrete and distinguishable in substance, though the 'MANDATORY SECURITY GATE' framing is hype and the core function overlaps conceptually with siblings like checkWalletDrainer and analyzeEvmWallet.

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?

A 'Usage:' clause is present, giving trigger contexts (auditing smart contracts, analyzing wallets, validating DEX liquidity). However, the triggers are overbroad and collide with many siblings (auditMcpToolPoisoning, inspectPhishingUrl, getSafeBaseTrending), and there is no when-not or explicit alternative routing.

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