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

Annotations already establish readOnly, idempotent, non-destructive, open-world behavior. The description's one genuinely additive fact is the L402 payment requirement (90 sats), which annotations do not convey. However, it says nothing about what the verifier returns, what a failed integrity check looks like, or any latency/billing 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?

A single short sentence with no padding, so nothing is wasted. But its brevity comes from under-specification rather than tightness — the one sentence does not carry enough information for the dimensions above.

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

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

For a paid, two-string tool with no output schema and no annotation coverage of return values, the description should explain what integrity verification produces and how failures are signaled. Instead it leaves the core semantics and output completely 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?

Both required parameters (original_transcript, compacted_summary) have 0% schema description coverage, and the description adds nothing about them. It does not clarify expected format, size limits, ordering, or the relationship between the two strings.

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?

"Context Compaction Integrity Verifier" is essentially a restatement of the tool name, with "Autonomous" and the price tag added. It never states what verifying entails (e.g., checking a summary against a transcript for dropped facts) or how it differs from siblings like agent_hallucination_auditor or ai_summarize.

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

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

There is no guidance on when to call this versus alternatives such as agent_prompt_compiler, ai_summarize, or agent_hallucination_auditor. No preconditions, no exclusions, no mention of what a user should supply first.

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 safety profile (readOnly, idempotent, openWorld, non-destructive), lowering the bar. The description nonetheless adds a genuinely useful behavioral fact — '150 sats via L402' — signaling a paid invocation and payment protocol requirement. It still omits what the audit returns or how it processes evidence.

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

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

It is a single front-loaded clause with no filler, but brevity here reflects under-specification rather than tight editing. Nothing is wasted, yet almost nothing is said.

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

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

For a paid, two-parameter auditing tool with no output schema and no parameter documentation, the description is far too thin. An agent cannot tell what result to expect, how the claim/evidence are consumed, or what the payment flow requires, so it is incomplete given the tool's complexity.

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

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

Schema description coverage is 0% for two required parameters, so the description carries the full burden of explaining 'claim' and 'retrieved_evidence'. It provides no parameter meaning at all, leaving both undocumented in schema and description alike.

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

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

The description names the resource (Agent Hallucination & Factuality) but does so by near-verbatim restatement of the tool name, offering no operational verb for what 'auditing' actually does. An agent can infer it checks a claim against evidence, but the description itself supplies no distinct purpose statement and no differentiation from the many agent_* siblings.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance whatsoever. The only extra information is a price, which says nothing about selection context.

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

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

Annotations already declare readOnlyHint, destructiveHint=false, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds useful context by disclosing the cost and payment rail ($0.02 USDC via x402 / 70 sats), but it does not explain what the tool actually returns, whether it merely diagnoses or also blocks, or how the circuit breaker behaves.

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 definition is a single compact sentence with no filler, and the pricing information is appropriately parenthetical. It is front-loaded with the core capability, though the lack of an explicit verb makes the sentence less actionable 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 a tool with one required structured parameter, no output schema, and no schema descriptions, the definition is incomplete. It does not explain what the parameter should contain, what constitutes a semantic loop or token-burn condition, or how the result should be interpreted.

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

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

The single required parameter, recent_action_trace, is an array of objects with 0% schema description coverage. The description repeats the phrase 'action-trace' but provides no detail about the expected object structure, required fields, or format, leaving the parameter essentially undocumented.

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 identifies a specific capability (semantic loop and token-burn circuit breaker) for a specific input (agent action-trace), which distinguishes it from siblings like agent_mcp_router or regex_oracle. However, it lacks an explicit verb such as 'detect', 'analyze', or 'halt', so the agent must infer the actual operation from a compressed noun phrase.

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

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

No guidance is given about when to invoke this tool versus alternatives, nor are there any exclusions or prerequisites. The payment details imply a cost-based context, but the agent is not told when a loop or token-burn check is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context the annotations lack: a 150-sat cost paid via L402, which tells the agent this call has a monetary/auth requirement. It still omits what the audit inspects, its depth, and latency.

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

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

A single tight sentence with the tool purpose front-loaded and the pricing/payment note appended. It is appropriately sized and wastes no words, though the phrasing is a label rather than an explanatory statement.

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 carries the burden of explaining return values, yet it says nothing about what the audit produces (findings, severity, verdict). Combined with an undocumented input parameter, the definition is too thin for a security-audit tool, even though annotations cover the read-only safety profile.

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

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

The single parameter manifest_url_or_json has 0% schema description coverage, so the schema contributes nothing, and the description adds no clarification about it either. The parameter name implies URL-or-raw-JSON input, but the description never confirms the accepted formats or whether JSON must be inline, leaving the sole input under-specified.

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

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

The description names the resource (MCP Manifest & Tool Poisoning) and implies the action (audit), so an agent can tell it relates to scanning MCP manifests for poisoning. However, it uses a noun phrase ('Auditor') rather than a verb, and never states what the audit actually does or returns, leaving the purpose partially vague against siblings like mcp_rugpull_diff and mcp_sampling_guard.

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

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

There is no when-to-use guidance, no exclusions, and no naming of alternatives such as mcp_rugpull_diff or mcp_sampling_guard, which overlap in the MCP-security space. The word 'Autonomous' hints that it runs without further interaction but does not tell the agent when this tool is the right pick.

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 safety profile (readOnly, idempotent, non-destructive, open-world), so the description doesn't need to restate it. It does add genuinely useful context beyond the annotations: a cost/auth requirement of '100 sats via L402' and a 'deterministic' output claim. It stops short of explaining failure modes, payment flow, or what a returned sequence looks like.

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

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

A single, front-loaded sentence that packs verb, resource, output form, and pricing without filler. It earns its length, though the parenthetical pricing detail sits slightly awkwardly 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?

For a one-parameter tool with no output schema, the description should carry more of the return/behavior burden. It hints at the output (JSON-RPC 2.0 payloads) and the L402 payment gate, but omits how the mapping is returned, its determinism guarantees, and any usage constraints.

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

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

Only one parameter (objective) with 100% schema description coverage, so the schema already carries the semantics. The phrase 'autonomous agent goals' loosely echoes the objective param but adds no format, granularity, or example beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb (Maps) and a concrete transformation: agent goals -> deterministic MCP tool call sequences and JSON-RPC 2.0 payloads. This clearly distinguishes it from siblings like agent_schema_enforcer or agent_loop_circuit_breaker, though it never names an alternative directly.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of when a sibling router (e.g. eve_gate_route_planner, mpp_deep_search) would be preferable. The agent must infer applicability entirely from the purpose sentence.

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, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact beyond annotations: the operation costs 100 sats via L402 payment, which an agent must know before invoking. It still omits what the output looks like and whether any auth/payment handshake is required.

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

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

It is a single short fragment with no wasted words, but it is so terse that it reads as a title rather than a front-loaded informative description. Brevity here reflects under-specification more than disciplined conciseness.

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

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

For a 2-parameter tool with no output schema, the description should clarify the transformation performed, the effect of strict_xml, and the paid L402 flow. It delivers only the payment hint, leaving an agent without enough information to invoke it confidently.

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 only 50%: raw_prompt is documented ('Raw unformatted instructions') but strict_xml has no description in the schema. The tool description adds nothing about either parameter or about what strict_xml toggles, so it fails to compensate for the coverage gap.

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

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

The phrase 'XML Agent Prompt Optimizer' names the resource (agent prompt) and the transformation (optimization to XML), so the general intent is inferable, but it is written as a marketing title rather than a stated verb+action, and it does not distinguish this tool from the many sibling agent_* tools (e.g. agent_context_compaction_verifier, agent_hallucination_auditor).

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

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

The description provides no when-to-use guidance, no prerequisites, and no alternatives among the sibling tools. The only contextual cue is the pricing note '(100 sats via L402)', which does not help an agent decide when to select 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 the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely new behavioral context by disclosing the L402 payment requirement (75 sats). However, it says nothing about what 'hallucination pruning' actually removes, what happens on validation failure, or whether output is returned or rejected.

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

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

A single compact sentence that front-loads the three core capabilities and tucks the payment detail into a parenthetical. No wasted words, though the density borders on terse.

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

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

For a tool with a nested-object 'schema' parameter, no output schema, and zero parameter documentation, the description is far too thin. It omits return behavior, failure semantics, and the meaning of its two inputs, leaving the agent guessing about how to call it correctly.

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

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

Schema description coverage is 0% for both parameters, so the description needs to carry the load and does not. It never explains that 'schema' is the JSON Schema to enforce or that 'raw_output' is the text to validate/heal, leaving the agent to infer the relationship between the two.

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

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

The description gives concrete actions (JSON Schema validation, type healing, hallucination pruning) that identify the resource and behavior. It is clear what the tool does, but it never differentiates itself from the close sibling json_repair (or guardrail_verify), so an agent may struggle to pick between them.

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

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

There is no guidance on when to use this tool versus alternatives such as json_repair or guardrail_verify, and no description of the conditions under which it applies. The trigger context is left entirely to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is largely covered. The description adds genuinely new behavioral context — AST-level analysis and a mandatory L402 payment of 75 sats — but says nothing about what the guard returns (a verdict, findings, etc.).

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

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

A single tight sentence with the core function and cost front-loaded. Nothing is wasted.

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

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

With no output schema, the description should at least indicate the shape of the response (pass/fail verdict, detected issues). It covers payment and analysis depth but omits input expectations and return semantics for what is a validation tool.

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

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

Schema description coverage is 0%, yet the description never mentions sql_query or dialect. With two undocumented parameters, the description fails to compensate for the schema gap, leaving the agent to infer input format and dialect handling on its own.

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

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

States a specific verb-resource combination: it guards/validates SQL for injection at the AST level. An agent can tell it analyzes queries rather than generating or executing them, but the description does not distinguish it from nearby siblings like guardrail_verify or tool_output_firewall.

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

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

No when-to-use guidance, no prerequisites, and no pointer to alternatives. The only extra context is pricing, which doesn't help an agent decide when this tool is the right choice over other guard/verify siblings.

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

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

The description claims 'autonomous agent with remote execution and tool use', which is a non-deterministic, side-effecting capability, yet annotations declare readOnlyHint=true and idempotentHint=true. That is a direct contradiction. The L402 payment disclosure (500 sats) is genuinely useful behavioral context, but it does not offset the safety-profile conflict.

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

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

A single compact sentence with the key facts (provider, capability, cost) front-loaded and no waste. It is efficient but arguably under-specified rather than appropriately concise for a complex autonomous agent.

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 open-world autonomous agent with a payment requirement, no output schema, and an undocumented sandbox_mode parameter, the description is far too thin. It omits execution scope, limits, what the agent returns, and how sandbox modes differ.

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

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

Schema coverage is only 50%: 'goal' is documented but 'sandbox_mode' carries only a default ('cloud_secure') with no description or enum, implying other modes exist that are never enumerated. The description adds no parameter meaning whatsoever to compensate.

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

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

Names a specific product (Google Antigravity) and states its capabilities (autonomous agent, remote execution, tool use), so an agent can infer it dispatches a goal to an autonomous runner. However, it never states the action verb directly and does not distinguish itself from near siblings like ai_computer_use or ai_code_gen.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. Nothing tells the agent when this autonomous agent is preferable to ai_deep_research, ai_computer_use, or code_sandbox, despite heavy sibling overlap.

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 safety profile (readOnly, idempotent, non-destructive, open-world). The description adds genuinely new behavioral context that annotations cannot: the 300 sats cost and the L402 payment requirement. It still omits what the tool returns (raw audio vs. transcript) and any latency/streaming behavior, so it's additive but incomplete.

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

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

A single tight sentence with no wasted words, and the differentiator and price are front-loaded. Efficient, though it sacrifices detail for brevity.

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 describing the return (audio bytes? format? text?), which it does not. It does cover the notable payment/behavioral angle, leaving it adequate but incomplete for an unfamiliar audio tool with an undescribed 'format' parameter.

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

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

Schema coverage is only 50% — audio_base64 is documented in the schema, but 'format' (with a 'pcm' default) has no description anywhere. The description says nothing about parameters, so it fails to compensate for the coverage gap.

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

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

States a specific resource and modality ('audio-to-audio conversational intelligence') and implicitly distinguishes itself from the ai_tts sibling by explicitly ruling out the STT/TTS cascade. However, 'conversational intelligence' is vague about what the tool actually produces (audio reply? text transcript?), so it isn't fully self-explanatory.

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 'without STT/TTS cascade' clause implies when to pick this over a cascade-based sibling like ai_tts, which is useful implied routing. But there is no explicit when-to-use, when-not-to-use, or prerequisite guidance beyond that.

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 safety (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description adds a genuinely useful operational fact: it costs 300 sats via L402, which implies a paid/auth-gated call. It does not disclose latency despite the 300-second hint or how output is returned. Adequate but not rich. No contradiction with the readOnly/idempotent hints.

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

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

A single front-loaded fragment with zero filler; the core capability and the payment cost are stated immediately. It is arguably too terse given the gaps elsewhere, but there is no wasted text.

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

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

No output schema exists, so the description carries the burden of saying what comes back (raw code text? file? partial script?), and it does not. For a generative tool with an undocumented language parameter and no sibling routing, an agent lacks what it needs to invoke this confidently.

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

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

Schema coverage is only 50% (language has a default but no description), so the description must compensate, and it does not mention either parameter. The only hint is 'Python' in the title, which merely restates the schema default. No syntax, format, or effect of the language override is explained.

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

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

States a specific resource (Python scripts and scrapers) generated via Gemini models, so an agent can tell it produces code rather than running it. It does not differentiate from nearby siblings such as ai_generate or code_sandbox, so it stops short of a 5. The fragment phrasing (no sentence) and narrow 'Python & scraper' framing also leave the scope slightly ambiguous against the language parameter.

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

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

No when-to-use, when-not-to-use, or alternative is named; the only extra context is the payment model. The agent must infer that this is for code-generation requests versus code_sandbox (execution) or ai_generate (generic text). Payment cost is not usage guidance.

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

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

The description enumerates an interaction agent whose schema actions are 'click, type, key' - operations that mutate the desktop and browser state - while the annotations declare readOnlyHint=true and idempotentHint=true (the tool does not modify its environment and repeated calls are equivalent). That is a direct and dangerous mismatch: an agent could invoke it on a live machine believing it is a safe, non-mutating read. The only genuine added behavior (the L402 payment cost) does not outweigh the contradiction.

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

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

A single front-loaded sentence with no filler; the purpose leads and the pricing parenthetical is compact. It is appropriately sized, though brevity is partly achieved by omitting necessary detail.

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, open-world automation tool with 33% schema coverage, no output schema, and misleading read-only annotations, the description leaves key gaps: coordinate format, what the agent returns, side effects, and how the L402 payment is satisfied. The pricing note is the only substantive addition.

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 only 33% - only 'action' carries documentation ('click, type, key, or screenshot') while 'text' and 'coordinate' are bare. With low coverage the description should compensate, but it says nothing about parameter semantics, so the array-of-integers coordinate format and the role of 'text' remain unexplained.

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

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

The description names a domain (OS-level desktop, GUI, and browser automation) and calls itself an 'interaction agent,' which is more informative than a bare name restatement, but it never states a concrete verb or what a single invocation actually accomplishes. It also fails to differentiate itself from related siblings such as ai_robotics or ai_antigravity_agent, so an agent gets the general area but not a crisp 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 no statement of when to choose this tool over alternatives, no preconditions, and no exclusions. The only extra context is the price '(800 sats via L402),' which hints at a paid, authenticated call but does not guide tool 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 cover the safety profile (readOnly, openWorld, idempotent, non-destructive), so the bar is lower, and the description adds two genuinely useful facts beyond them: the operation is multi-hour and costs 1000 sats via L402, i.e. a payment gate. It stops short of describing output format or what happens on payment failure, 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?

A single front-loaded sentence with no filler; the cost and duration are the highest-signal items and appear immediately. It is arguably under-specified rather than over-long, but as a sizing/structure judgment it is efficient.

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

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

With no output schema and no return-format prose, an agent cannot tell what a 'deep research' call yields, how long to expect, or what the depth parameter does. For a paid, multi-hour, 2-parameter tool this is a substantial missing piece.

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

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

Schema coverage is only 50% – target_query is documented but 'depth' has no description and no enum, so its allowed values are unknowable. The description says nothing about depth levels or how they change behavior, so it fails to compensate for the schema gap.

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

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

Names the resource as an 'investigative analysis engine' and communicates the deep, long-running nature of the research, which is more than a tautology. However it never states a crisp verb+output (report? answer? citations?) and gives no differentiation from the sibling mpp_deep_search, leaving ambiguity about what the tool actually produces.

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

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

The phrase 'multi-hour' implies this is for heavy, long-horizon investigations rather than quick lookups, but there is no explicit when-to-use guidance, no exclusion criteria, and no mention of the related mpp_deep_search 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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds genuinely new behavioral context: the tool is metered and requires an L402 payment of 50 sats, which affects whether and how an agent calls it. It stops short of describing rate limits, error/payment-failure behavior, or the shape of the returned vector.

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

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

A single dense sentence that front-loads the output characteristics and purpose, then appends cost. No filler, nothing that could be cut without losing information.

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

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

For a two-parameter tool with annotations covering safety, the description supplies purpose, dimensionality, and payment cost. But with no output schema it never says what the response looks like (raw float array, base64, etc.), and the `model` parameter remains unexplained, leaving gaps an agent must guess at.

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

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

Schema coverage is only 50%: `text` is documented but `model` (default gemini-embedding-2) has no description anywhere. The description never mentions model selection or the available embedding models, so it does not compensate for the coverage gap; the 3,072 figure describes output, not a parameter.

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

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

The description states a concrete verb+resource (text embeddings), quantifies the output (3,072-vector) and names the use case (semantic search). It does not distinguish itself from the sibling x402_embeddings, which appears to serve the same purpose, so an agent cannot route between them from this 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?

'For semantic search' implies the intended use case, and the parenthetical '50 sats via L402' signals that invocation costs money, which is relevant to deciding whether to call it. However, there is no explicit when-to-use/when-not guidance and no mention of the near-identical x402_embeddings 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, idempotentHint, openWorldHint and destructiveHint=false, covering the safety profile. The description adds a genuinely useful behavioral fact not in the annotations: the operation costs '150 sats via L402', implying a payment/auth gate. It does not describe output format or failure modes, so it exceeds the annotation baseline only modestly.

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

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

A single front-loaded sentence with no filler; the resource is named before the price qualifier. It is efficient, though it packs the cost detail into the same clause rather than separating it.

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

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

With no output schema, the description should carry the burden of explaining the returned JSON shape, but it only says 'Structured JSON' without indicating what fields or entity structure to expect. For an extraction tool the return contract is the key missing piece.

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 'text' and 'target_entities'. The description adds nothing about parameter format, defaults, or how target_entities affects extraction, 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 states a specific verb+resource ('Structured JSON Entity Extractor from arbitrary unformatted text'), which tells an agent exactly what it produces. It doesn't differentiate from near siblings like json_repair, clean_data, or ai_summarize, but the core purpose is unambiguous.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives such as ai_summarize or json_repair. The only contextual signal is the price, which is a cost note rather than routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description does add genuinely new context in the pricing ('250 sats via L402'), but it is cryptic and leaves the payment flow, latency, and output shape unexplained.

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

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

A single front-loaded sentence with no filler, which is structurally clean. It is arguably under-sized for a tool with a payment mechanism and an undocumented model parameter, but nothing in it is wasted.

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

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

For a 3-parameter, open-world generative tool with no output schema, the description omits the return format, what 'Tier 1' means, how L402 payment is settled, and what happens with grounding. Too little is disclosed for the agent to call it confidently beyond the bare minimum.

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?

At 67% schema coverage, the description adds essentially nothing about parameters: it never mentions 'prompt', 'grounding', or the model parameter by name. 'Supporting 45 foundation models' hints at the model parameter's value space but gives no enumeration or discovery path, and the default gemini-2.5-flash is only in 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 resource ('model generator') and a scope ('45 foundation models'), so the agent can tell it produces model output. But 'Universal Tier 1' and 'generator' are jargon that never state the actual operation (text/completion generation from a prompt), and it does not distinguish itself from siblings like ai_code_gen, ai_summarize, or ai_omni.

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

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

There is no when-to-use guidance at all: no condition selecting this over ai_code_gen, ai_summarize, ai_grounded_search, or ai_omni, and no mention of when the grounding parameter should be set. The agent must infer routing purely from the tool name.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered without the description. The description does add one real behavioral trait absent from structured fields: this is a paid call (250 sats via L402), which matters for an agent's cost accounting. It says nothing about latency, result shape, or rate limits, so it stays mid-range.

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

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

A single front-loaded sentence that names the capability first and appends the payment cost as a parenthetical. Zero padding, though it is so terse that it omits information the agent needs, which is a completeness issue rather than a structural one.

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

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

For a two-parameter tool with no output schema, the description covers the safety profile via annotations and the cost via text, but leaves the location parameter undocumented and offers no routing guidance against ai_grounded_search. Adequate but with clear 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 coverage sits at 50%: place_query is documented as 'Place or spatial query' but the location parameter has no schema description. The tool description adds no parameter meaning at all, so the undocumented location field is left unexplained in both places.

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: grounded reasoning over live Google Maps place details and spatial context. It is distinguishable from generic search tools by the explicit 'Google Maps' and 'spatial context' framing, but it never names or contrasts with the obvious sibling ai_grounded_search, so the boundary is left to inference.

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

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

The description gives no when-to-use, when-not-to-use, or alternative guidance despite a very close sibling in ai_grounded_search. The only contextual cue is the L402 price, which implies a paid call but does not say when this tool beats its alternatives.

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, idempotent, open-world, non-destructive, so the safety profile is covered. The description adds genuine non-annotation context — the grounding source (live Google Search) and the L402 payment requirement of 200 sats — but omits latency, result shape, and whether payment is per-call.

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

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

A single compact sentence that front-loads the core capability. Nothing is wasted, though the parenthetical cost detail is appended rather than framed as decision-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?

No output schema exists, so the description should carry more of the burden. With search_mode fully undocumented anywhere and no statement of return format or payment behavior, an agent lacks enough to call this confidently versus its many search 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 only 50% and the undocumented parameter is search_mode, which the description never mentions at all. The description therefore does not compensate for the coverage gap; an agent learns nothing about what modes exist or what the default 'live' means.

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

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

States a clear capability: reasoning grounded in live Google Search results. It distinguishes itself functionally from generic chat, but gives no differentiation from siblings like ai_deep_research, mpp_deep_search, or web_brief, which an agent would need to choose between.

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

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

No when-to-use guidance, no conditions, and no named alternatives despite several overlapping search/research siblings. The '(200 sats via L402)' fragment hints at a cost gate but never says when paying for this is preferable to a free 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, idempotentHint=true, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful context the annotations lack: the 350 sats L402 payment requirement and the model cost tier. It does not describe the return format or latency for a paid generation call.

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

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

A single front-loaded sentence with no filler. The parenthetical pricing is dense and slightly cryptic but earns its place by flagging cost. Efficient overall.

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 generation tool with no output schema and only 33% schema coverage, the description leaves the agent without parameter meanings, valid values, or any sense of the returned artifact. Purpose and cost are present, but too much is left to inference.

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

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

Schema coverage is only 33%: prompt is documented as 'Visual prompt' while model and aspect_ratio carry no descriptions. The description partially compensates by tying the model names (Nano Banana / Pro) to the run and hinting at photorealistic vs vector output, but aspect_ratio and valid model values remain unexplained.

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

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

States a specific verb (generation) and resource (photorealistic and vector assets), and names the underlying models (Nano Banana / Pro). An agent can tell it produces still images rather than audio/video siblings. It stops short of explicitly contrasting with ai_video_gen or ai_music_gen, so 4 rather than 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?

There is no statement of when to use this tool versus alternatives, nor any prerequisites beyond an implicit cost. The mention of a price is not usage guidance. An agent gets no routing help against the crowded ai_* sibling set.

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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful cost context (500 sats via L402), which tells the agent this is a paid, payment-gated call, but it says nothing about return format, latency, or model/version behavior.

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

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

A single front-loaded sentence with no filler; the capability is stated before the cost. It is efficient, though brevity here shades into under-specification rather than disciplined concision.

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 tell the agent what it receives back (audio URL, base64, job handle), and it does not. Combined with the low parameter coverage, the definition is adequate to attempt a call but not to predict or handle 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 only 33% — genre and duration_seconds carry no schema description — and the prose does not compensate. It never mentions what genre accepts, the granularity of duration_seconds, or the default of 30 seconds, leaving two of three parameters undocumented end to end.

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

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

Names a specific capability (musical composition and instrumental audio generation) and the underlying provider (Lyria), which distinguishes it from ai_tts and ai_audio_live. It stops short of explicitly contrasting itself with the many ai_*_gen siblings, but the resource is unambiguous.

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

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

The description offers no when-to-use context, no exclusions, and no routing toward or away from alternatives like ai_tts or ai_audio_live. The only guidance is pricing, which is not a usage rule.

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description's real contribution is the operational constraint that each call costs 300 sats via L402, a payment/auth requirement an agent must know before invoking. It stops short of describing latency, output format, or how the L402 payment is actually settled.

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

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

A single front-loaded sentence with no filler; every clause (unified multimodal, three modalities, price) carries information. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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

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

With no output schema and no annotations covering inputs, the description should explain return shape, media input handling, and size limits. It supplies only the payment cost, leaving an agent unable to predict output or correctly construct a media-bearing request.

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

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

Schema coverage is only 50%: 'prompt' is described circularly as 'Multimodal prompt' and 'media_url' has no schema description at all. The description's mention of audio and video hints that media_url carries non-text input, but it never says the format (URL vs base64), whether media_url is required for audio/video prompts, or what the prompt should contain.

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 capability: a unified model accepting text, audio, and video simultaneously. That combination distinguishes it implicitly from single-modality siblings like ai_audio_live, ai_video_gen, and ai_generate, though the description never names or contrasts those alternatives. The verb 'handling' is soft but the resource is unambiguous.

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

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

There is no when-to-use guidance, no exclusions, and no comparison to the many ai_* siblings that overlap in scope. The only routing signal is the embedded cost note, which tells the agent the call is paid but not when it beats a cheaper single-modality 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 readOnly, idempotent, non-destructive, and openWorld, so the safety profile is covered. The description adds genuinely new behavioral context in the form of a payment cost (450 sats via L402), which an agent must know before invoking. However, it omits how the payment is supplied (header, token) or what happens on payment failure.

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

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

It is a single front-loaded sentence with no filler, which is structurally clean. But the brevity is achieved by omission rather than economy – critical calling information is simply absent, so it reads as under-specified rather than 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 tool with two entirely undocumented parameters, no output schema, and a paid L402 invocation path, the description leaves the agent without input format guidance or payment mechanics. The capability list and cost note are the only anchors provided.

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

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

Schema description coverage is 0% for two parameters, one of them required, and the description mentions no parameters at all. An agent gets no guidance on what scene_description should contain or what target_object is for, so the description fails to compensate for the schema gap.

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

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

The description names three concrete capabilities (spatial reasoning, kinematics trajectory calculation, robotics task planning) with a clear domain, so an agent knows what it will get. It falls short of 5 because it doesn't distinguish itself from adjacent siblings such as ai_computer_use or ai_antigravity_agent, leaving the routing decision partly ambiguous.

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

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

There is no statement of when to use this tool versus alternatives, nor any precondition or exclusion. The parenthetical cost note is the only context, and it doesn't help an agent decide between this and other ai_* tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered structurally. The description's one real contribution is the L402 payment requirement (100 sats), which is genuine behavioral context an agent must know before calling. It omits output length/format behavior and any failure/payment-failure handling, so it adds value without being 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?

A single short sentence with the core function front-loaded and the cost note appended, with no filler. It is terse to the point of being a fragment, which slightly under-serves rather than over-serves, but nothing is wasted.

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

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

There is no output schema, so the description carries the burden of describing what comes back, and it says only 'brief' — no length, format, or structure. With max_tokens undocumented and no return-value guidance, an agent cannot predict the response shape before paying.

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 exactly 50%: 'content' is documented but 'max_tokens' (default 500) has no schema description, and the description adds nothing about it. With half the parameters undocumented at both the schema and description level, the description fails to compensate for the gap.

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

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

The description names a concrete function — summarizing content into an executive/technical brief — which is distinguishable from siblings like ai_extract (extraction) or ai_generate (open-ended generation). It is phrased as a noun/title fragment rather than a verb+resource statement, and it never names web_brief or ai_extract as the closest alternatives, so it stops short of full differentiation.

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

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

There is no statement of when to choose this tool over neighbors such as ai_extract, web_brief, or ai_generate, and no prerequisites beyond the price note. An agent must infer applicability from the name alone.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by disclosing the cost and payment path: 200 sats via L402. It does not cover latency, limits, or output format, but the added payment/auth detail is significant.

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

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

The description is a single front-loaded sentence with no wasted words. However, its brevity comes at the cost of missing usage and parameter context, so it is efficient but under-informative.

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

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

For a simple two-parameter synthesis tool with annotations covering safety and no output schema, the description is minimally adequate. It omits voice semantics and when-to-use guidance, but the added L402 payment context helps compensate.

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

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

Schema coverage is only 50%, and the description does not explain the undocumented voice parameter or its default value. It also adds no detail about text constraints or available voice options, leaving the agent to infer parameter behavior from the schema alone.

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 capability — natural expressive voice synthesis — and scopes it to Gemini TTS models, which distinguishes it from general audio tools like ai_music_gen. It does not explicitly contrast with the closest sibling, ai_audio_live, so it falls short of a 5.

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

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

The description gives no guidance on when to use this tool rather than alternatives such as ai_audio_live or ai_music_gen. There are no exclusions or decision criteria, only a high-level statement of capability.

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?

The annotations cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the description's job is to add context beyond that. It does add genuinely useful behavior: the provider (Veo 3) and a fixed per-call cost of 1500 sats settled via L402. However, it omits generation latency, whether the call is synchronous or returns a job handle, and the output artifact form, which matter for a paid, potentially long-running generation.

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

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

One front-loaded sentence with no filler; the core capability leads and the cost detail trails in a parenthetical. It is arguably too terse for the tool's complexity, but nothing in it is wasted.

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

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

There is no output schema, so the description should explain what comes back, and it does not — no mention of a video URL, file artifact, or job/polling semantics. For a metered, paid generation tool with one undocumented parameter, the description leaves an agent unable to predict either the cost flow or 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 only 50%: 'prompt' is documented ('Cinematic scene description') but 'resolution' carries no description at all. The description adds no parameter information beyond implying 'high-definition', so it fails to compensate for the undocumented resolution parameter and its default of 1080p.

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 ('cinematic video synthesis via Veo 3'), which is unambiguous and naturally distinct from the sibling generators ai_image_gen, ai_music_gen and ai_tts. It does not explicitly name or exclude any sibling, but the resource is clear enough that an agent can route to it without opening the schema.

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

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

There is no when-to-use guidance, no prerequisites, and no alternatives named. The parenthetical '(1500 sats via L402)' hints that a payment flow is involved but never says when this tool is the right choice versus ai_image_gen or a cheaper generator, nor what happens if payment is declined.

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

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

Annotations cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint), so the bar is lower. The description adds a genuinely important behavioral trait not present in the annotations: access is paid, costing 100 sats via L402. It still omits size limits, what 'cleanup' actually mutates in the returned data, and any error behavior.

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

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

A single front-loaded sentence with no filler; the operations lead and the payment caveat trails. It is efficient, though the parenthetical pricing slightly interrupts the core operation list.

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 need not describe return values, and the two parameters are fully covered by the schema. But for a tool that ingests untrusted data the description omits what 'cleanup' concretely produces (schema of output, dedup key, normalization rules) and any input size constraints, 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 only two parameters, so the schema already explains raw_data ('Untrusted raw CSV or JSON') and format ('csv or json'). The description adds nothing parameter-specific, so the baseline 3 applies.

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

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

Names three concrete operations (deduplication, normalization, dataset cleanup) on text/datasets, which is more specific than the bare tool name. However it never distinguishes itself from the nearest sibling, scrub_pii, and the resource ('text', 'dataset') stays somewhat abstract.

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

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

There is no statement of when to use this tool versus alternatives (e.g. scrub_pii, json_repair, regex_oracle). The only contextual cue is the pricing note, which is not selection guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds non-trivial context the annotations cannot express: the sandbox is paid ($0.15 USDC via MPP on Base) and is isolated. It omits execution constraints an agent would care about - timeouts, memory/network limits, and whether the sandbox has outbound access - despite openWorldHint implying it might.

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

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

One tight sentence with the capability front-loaded and the cost detail trailing; nothing is padded. It loses a point only because the brevity comes at the expense of essential execution details rather than being dense with them.

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

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

For a code-execution tool with no output schema, the description says nothing about what comes back - stdout, captured return value, or traceback on error - nor about timeout or isolation guarantees. An agent cannot predict the response shape or failure modes from the definition alone.

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 fully documents 'code'. The description contributes nothing further about the parameter - no language constraints, size limits, or whether non-Python text is rejected - 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 states a specific verb (execute) and resource (Python code) plus the isolation context ('secure sandbox'), which is enough to distinguish it from every sibling tool in this set. No sibling is named because none overlaps. It stops short of a 5 only because the execution semantics (in-line return vs. file artifacts) are left implicit.

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

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

There is no statement of when to reach for this tool versus an alternative, nor any prerequisite guidance. The pricing clause ('$0.15 USDC via MPP on Base') signals a paid call but does not tell the agent under what conditions the payment is worth making or what happens on failure/refund.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact not in the annotations: this is a paid operation billed at 250 sats via L402. It still omits turnaround, return shape, and what happens on payment failure.

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

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

A single tight sentence that front-loads the core purpose and appends the cost clause without filler. Every element earns its place.

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

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

For a paid audit tool with no output schema, the description leaves the return value entirely unexplained (score? report? severity breakdown?) and does not outline how the L402 payment step works for the caller. Adequate for invocation, thin for outcome expectations.

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 network (base/ethereum/solana) and code_or_address are already documented in the schema. The description adds no syntax, format, or accepted-address 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?

The description names a specific verb (audit) and resource (smart contract) plus the exact analysis classes it covers: honeypot, tax, and mint backdoor. It is clear what the tool does, though it never distinguishes itself from risk-oriented siblings like solana_risk or mev_risk.

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

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

There is no when-to-use guidance, no conditions distinguishing it from solana_risk/mev_risk, and no prerequisites for the caller. The only contextual detail is the price (250 sats via L402), which informs cost but not 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, idempotentHint=true, openWorldHint=true and destructiveHint=false, so safety and idempotency are covered structurally. The description adds real behavioral context the annotations lack — it is a paid L402 endpoint costing 100 sats — but says nothing about latency, what the analysis consumes, or what the output signifies.

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

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

A single tight sentence with the capability front-loaded and no filler. It is efficiently sized, though for a tool with this much unexplained surface area the brevity edges toward under-specification.

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

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

With no output schema and no annotations describing results, the description must explain what a check yields (risk flag, verdict, explanation), and it does not. Combined with two undocumented parameters, an agent cannot confidently interpret or 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 0%, so the description must carry parameter meaning and it provides none. target_address is self-evident, but transaction_history is completely opaque: the description does not state which chain, what format the string entries take, or why history is needed for poisoning detection.

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 capability — detecting address poisoning and vanity-address scams — which is a concrete verb+resource combination. It distinguishes itself reasonably well from broad siblings like solana_risk or mev_risk by naming a specialized attack type, though it never says what the tool actually returns (a verdict, score, or flag).

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

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

There is no guidance on when to call this versus alternatives such as solana_risk, mempool_fee, or mev_risk. The only extra information is a payment condition (100 sats via L402), which is a pricing note, not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context: the L402 payment cost of 100 sats and the non-KYC constraint. However it does not say whether payment is automatic, per-call, or how it is settled, so the disclosure is partial rather than 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?

It is a single front-loaded sentence with no filler, which is good, but the trailing '(100 sats via L402)' fragment is cryptic and the compression sacrifices clarity. Every clause earns its place, but readability suffers.

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 a caller gets back — yet it never states that it returns route/pricing options or their format. Combined with zero parameter documentation and no usage guidance, a moderate-complexity quoting tool is left materially under-described.

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?

All three parameters are undocumented in the schema (0% coverage), and the description supplies no format for from_asset/to_asset identifiers or units/semantics for amount. 'Compares cross-chain routes' gestures at asset pairs but adds no usable parameter meaning, leaving the agent to guess at valid 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?

It states a specific verb (Compares) and resource (non-KYC cross-chain settlement routes) and names the actual providers (THORChain, Blockstream Liquid, Maya). No sibling tool overlaps this domain, so differentiation is moot. It is clear what the tool does, though the quoted-deliverable nature (a quote/route comparison result) is only implied.

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

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

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no named alternatives. The only contextual cue is 'non-KYC', which hints at a suitability condition but does not direct the agent's 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, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds one genuinely useful behavioral fact: a payment requirement (100 sats via L402). It does not explain what the decoding returns or how phishing verdicts are surfaced.

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

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

A single front-loaded sentence with no filler, stating the capability first and the cost second. Nothing is wasted, though it is arguably too terse for the schema's complexity.

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, no parameter descriptions, and a nested object parameter, the description is far too thin to tell an agent how to call it or what to expect back. For a paid decode tool this leaves major 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 0%, so the description carries the full burden for the two parameters. It only obliquely maps 'typed_data' and (via 'Permit2') 'spender'; format, structure, and required-ness of these fields are not clarified anywhere.

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 (decode) and resource (EIP-712 typed data / Permit2 payloads) for a phishing-analysis purpose, distinguishing it from siblings like crypto_address_poisoning_check. The scope is clear, though it doesn't explicitly route to an alternative 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?

There is no statement of when to use this versus alternatives, nor any prerequisites beyond the price. The agent learns the cost but not the context that should trigger the 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 declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful non-annotation fact: it costs 80 sats via L402, which signals a paid endpoint. It does not describe what a returned 'plan' contains or what UTXO object shape is expected.

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

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

A single front-loaded line with no padding. Efficient, though the terse parenthetical pricing note is the only elaboration, leaving no structure for anything else.

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 a loosely typed items:object UTXO array, the description should explain what a consolidation plan returns, how UTXOs are structured, and how the L402 payment is handled. None of that is present, leaving real gaps for a tool with a required structured parameter.

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% ('UTXO array', 'Target sat/vB'), so the schema already carries the parameter meaning. Baseline 3 applies; the description contributes no additional parameter semantics such as expected UTXO fields or fee-rate units beyond the schema.

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

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

States a specific resource and action: Bitcoin UTXO dust consolidation plus fee optimization. An agent knows what the tool produces conceptually. It does not differentiate from nearby siblings like mempool_fee or swap_rate, but the purpose itself is unambiguous.

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

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

No when-to-use guidance, no prerequisites, and no named alternative. An agent cannot tell from the text whether to reach for this vs mempool_fee for fee insight or any other crypto sibling. Usage is only implied by the name.

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, idempotent, non-destructive, openWorld), so the bar is lower. The description does add a genuinely useful trait not present in annotations: the call is metered and costs 100 sats via L402. However, it does not say whether payment is required up front, how failure/payment errors surface, or whether results are cached.

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

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

A single tight sentence with no filler, and the core purpose plus cost model are front-loaded. It is appropriately sized, though the dense parenthetical about L402 could be 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 is responsible for conveying what comes back (route, jump count, toll/fuel estimate) and it says nothing. It also omits the format expected for the two required system-name parameters and how the L402 payment is actually settled, leaving key invocation details unknown.

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 only 33%: origin_system and destination_system have no descriptions in either the schema or the description, and the description supplies no naming convention or format for them. With low coverage the description is expected to compensate, and it does not.

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

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

States a specific verb+resource combination ('routing optimizer' for gate toll and fuel across EVE Frontier star systems), so the agent knows this computes a route with cost objectives. It does not differentiate itself from the nearest sibling (eve_network_node_gj_optimizer), leaving the boundary to be inferred.

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. The agent must infer that this is the tool for inter-system travel routing purely from the name and the word 'optimizer'.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious operational context: the tool costs 150 sats via L402, meaning the agent must anticipate a Lightning payment challenge. That is real value beyond the structured fields, though return format and rate limits remain undisclosed.

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

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

A single front-loaded line with no filler, so it is appropriately sized. It is terse to the point of under-specification rather than sprawling.

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

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

For a 2-parameter tool with no output schema and no parameter documentation, the description is far too thin: it explains neither inputs, outputs, nor time-window semantics. The L402 cost note is the only substantive detail present.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining parameters, and it explains neither solar_system_id (format/identifier type) nor lookback_hours (beyond the schema default). The payment parenthetical adds no parameter meaning.

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

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

The description names the domain (killmail threat intel) and a scope (ambush radar), which is more than a restatement of the name, but it uses no clear verb and offers no way to distinguish this from siblings like eve_gate_route_planner or eve_sovereignty_fuel_radar. An agent gets the topic area but not a precise statement of what the tool returns or does.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance whatsoever. The parenthetical payment note does not help the agent decide between this and other EVE tools.

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

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

Annotations already declare the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the description only needs to add context. It does add the paid/L402 aspect, which the annotations do not cover, but it omits what is actually produced (generated Move code, an audit report, or both) and how the payment flow is triggered.

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

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

A single sentence with no filler, and the core purpose (synthesize/audit Move extensions for Smart Assemblies) is front-loaded before the parenthetical cost detail. Nothing needs trimming.

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, no-output-schema tool with a full annotation set, the description leaves real gaps: the deliverable is unspecified, the overlap with the sibling contract_audit is unresolved, and the L402 payment mechanic is mentioned but not explained. It is adequate to identify the tool but not complete enough to invoke it confidently.

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 carry descriptions, so the baseline is 3. The description adds nothing about assembly_id or contract_type beyond what the schema already says, though it does imply the domain (Smart Assemblies) that contextualizes assembly_id.

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 specific verbs (synthesizes and audits) and a specific resource (Sui Move smart contract extensions for EVE Frontier Smart Assemblies), which is far more informative than the tool name alone. However, it does not differentiate itself from the sibling 'contract_audit', despite claiming an auditing role, so an agent cannot tell the two apart from the text.

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

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

There is no stated when-to-use, no prerequisites, and no routing to or away from alternatives such as contract_audit or code_sandbox. The only usage-adjacent information is the cost note '(200 sats via L402)', which tells the agent there is a price but not when invoking this tool is the right choice.

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 safety (readOnlyHint, idempotentHint, destructiveHint=false), so the description is not the primary carrier. It does add a genuine behavioral trait beyond annotations: a payment requirement of 100 sats via L402. However, 'offline-threat windows' is left unexplained and no return behavior is disclosed.

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

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

It is short but at the cost of clarity – a single cryptic fragment with no front-loaded action verb. Brevity here reflects under-specification rather than disciplined concision.

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 0% schema coverage, the description carries the full explanatory burden and falls well short. It omits what the tool returns, what 'optimizer' means, and how the two parameters drive behavior.

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

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

Schema description coverage is 0%, so the description must compensate, and it does not. Neither node_id nor reserve_gj is explained, and the phrase 'GJ energy reservations' only loosely gestures at reserve_gj without clarifying units, defaults, or valid ranges.

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 is a noun phrase listing topics (fuel burn, GJ reservations, offline-threat windows) rather than stating a verb+resource action. It never says what the tool actually does or what it optimizes, leaving the agent to guess from the name alone. It is closer to a restatement of the name's components than a 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?

There is no explicit when-to-use, when-not-to-use, or named alternative among the many sibling tools. The '(100 sats via L402)' fragment hints that the call is paid, which is faint context, but no routing guidance is offered.

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

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

Annotations already specify readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds a useful non-obvious trait: '140 sats via L402', indicating the endpoint is paywalled via Lightning. However, it does not explain payment flow, rate limits, or what the tool returns.

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 sentence is concise but under-specified for a tool with two parameters and no schema descriptions. Brevity here does not earn its place because it omits the operational verb and parameter context. It is not poorly structured, but it is too sparse.

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

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

Given the tool's open-world, paywalled nature and the absence of output schema and parameter descriptions, the description is incomplete. Annotations cover the safety profile, but the agent still lacks essential details about the operation, return data, and parameter 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?

Schema description coverage is 0%, and the description says nothing about the two parameters (solar_system_id required, tribe_id optional). It does not compensate for the missing schema documentation, leaving the agent without guidance on what values to supply or what tribe_id means.

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 is a noun phrase that essentially restates the tool name ('Sovereignty & Fuel Radar'), adding only 'Solar System' and a payment cost. It lacks a specific verb (e.g., retrieve, list, compute) that tells the agent what operation is performed. Thus it reads as a tautology rather than a clear 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?

No when-to-use context, no prerequisites, and no indication of how it differs from the many sibling EVE tools (e.g., eve_gate_route_planner, eve_killmail_threat_intel). The agent is left to infer when this radar is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description does add genuinely useful non-annotation context: the tool is paid, costing 120 sats via an L402 payment flow, which the agent must handle before calling. However, it says nothing about what the tool produces or how the market-maker logic behaves, so it is only a partial addition.

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

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

One compact sentence, front-loaded with the resource and appending the cost in parentheses; nothing is padded. It is concise but arguably under-sized for a three-parameter, payment-gated tool, which slightly weakens structure.

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

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

With three undocumented parameters, no output schema, and an open-world hint, the description is far too thin to tell an agent what the tool returns or how to call it. The payment requirement is the one substantive fact included, but operational behavior and parameter meaning are absent.

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

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

Schema description coverage is 0% across three parameters (ssu_id, item_id, inventory_count), so the description carries the full burden and does not compensate. The terms 'SSU' and 'Vending Pricer' faintly hint at the domain of ssu_id and item_id but give no semantics, and inventory_count is not referenced at all. This leaves required parameters essentially undocumented.

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

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

The description names the domain (SSU Automated Market Maker & Vending Pricer) but is a noun phrase with no verb, so it never says what the tool actually does – compute prices, place orders, or manage vending. It adds 'Vending Pricer' beyond the tool name, so it is more than pure tautology, but 'SSU' is unexplained jargon. Siblings in this family all have explicit verb+resource names, and this one gives no comparable action.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance; the only clause is a price disclosure. An agent cannot infer from the text whether this is for pricing, order placement, or market analysis. Cost alone does not route the agent among the EVE siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, which is consistent with an 'auditor/simulator'. The description adds one genuinely useful behavioral fact beyond the annotations: invocation requires an L402 payment of 150 sats, implying an auth/payment handshake. It does not describe execution behavior or results.

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

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

A single front-loaded sentence with no padding. The pricing parenthetical is arguably useful rather than waste, though the packed jargon slightly reduces scannability.

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

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

For an analysis/simulation tool with no output schema and 0% parameter coverage, the description should explain what a PTB audit returns or how commands are supplied. It instead stops at a label plus a price, leaving the agent unable to construct a correct 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 0% for two parameters, so the description carries the full burden and fails it. Neither ptb_commands (an array of command objects) nor expected_max_outflow_mist (the drain threshold) is explained, leaving the required 'ptb_commands' shape entirely undocumented.

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 domain (EVE Frontier & Sui Move PTB) and a task (coin-drain and HotPotato auditing), and the name implies simulation. But it oscillates between 'simulator' (name) and 'auditor' (description) without resolving what actually happens, and the jargon-heavy phrasing leaves the core action ambiguous to an agent.

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

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

There is no indication of when to use this tool versus siblings like contract_audit, solana_risk, or mev_risk. The only usage-adjacent detail is the L402 price, which tells the agent nothing about the conditions that should trigger 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, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description does add one piece of non-structured behavioral context — the '125 sats via L402' payment requirement, which signals a paid endpoint and potential payment-gated failure — but says nothing about authorization flow, rate limits, or what happens on non-payment.

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

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

It is a single front-loaded sentence with no padding, which is structurally fine, but it is terse to the point of under-specification rather than genuinely concise. The payment aside in parentheses is useful but orphaned.

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

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

For a tool with an opaque array-of-objects input, zero schema coverage, and no output schema, the description leaves the agent unable to construct a valid call or anticipate a result. It omits the domain framing (EVE Online turret/ship signature semantics) that the bare schema cannot supply.

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

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

Schema description coverage is 0% and the description adds no parameter meaning whatsoever. Critically, the required 'ship_signatures' parameter is an array of untyped objects with no properties and no documented element shape, and the optional 'turret_id' is never explained — the description does nothing to compensate for this gap.

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

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

The description is essentially a restatement of the tool name and title ('EVE TURRET TARGET MATRIX' → 'Smart Turret Friend-or-Foe & Target Matrix') with no verb saying what it computes. The 'Friend-or-Foe' phrase hints at IFF classification, but an agent still cannot tell whether this returns a target list, scores, or a friend/foe verdict.

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

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

No when-to-use, when-not-to-use, or alternative is given, and no sibling (e.g. eve_killmail_threat_intel, eve_gate_route_planner) is referenced. The agent must guess the operational context entirely.

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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description does add one genuinely useful behavioral fact beyond annotations: the 100 sats L402 payment requirement, which signals an auth/cost step. It still omits failure behavior, latency, and what constitutes a passing vs failing verification.

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

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

It is a single short sentence with no wasted clauses, and the payment caveat is visible up front. However, the brevity comes from omission rather than precision, leaving the core purpose unspecified.

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

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

For a tool with two required, fully undocumented parameters and no output schema, the description should explain what is verified and what the caller gets back. Instead it supplies only a name-like phrase and a price, so an agent lacks the information needed to call it correctly.

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

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

Schema description coverage is 0% for both required parameters, and the description offers no explanation of jwt_proof or ephemeral_public_key, their expected formats, or how they interrelate. With two undocumented required params, the description does nothing to compensate for the schema gap.

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

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

"Frontier Vault zkLogin & Character Verifier" largely restates the tool name with added branding; it never says what is being verified, against what, or what a result means. The parenthetical adds a price, not a purpose. An agent cannot confidently distinguish this from siblings like guardrail_verify or eve_gate_route_planner.

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

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

There is no indication of when to use this tool, what preconditions exist (other than payment), or which alternative handles related verification tasks. The L402 fee is stated but no context for choosing this tool over the many other verify/audit siblings is given.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact beyond those annotations: the call costs 100 sats via L402. It still omits what happens on detection (block, warn, or verdict) and any auth/payment flow details.

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

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

A single compact sentence with zero filler, front-loading the purpose before the cost note. The trailing L402 parenthetical is terse enough to be slightly ambiguous about whether it is a cost to the caller or a payment the tool performs, but there is no wasted prose.

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

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

There is no output schema, so the description carries the burden of explaining the return value, and it does not: an agent cannot tell whether it gets a boolean, a risk score, or a block/allow verdict, nor what the failure mode is when a threat is found. Given annotations cover safety and the two parameters are fully documented, the remaining gap is notably the detection outcome.

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 payload and action_type are already documented as 'Command, script, or prompt to inspect' and 'Action type (e.g. bash, tool_call)'. The description adds no syntax, format, or value 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?

The description states a specific verb+resource (a pre-execution security gate) and enumerates the threat classes it detects: prompt injection, wallet drain, key exfiltration. That is far more informative than a name restatement. It does not, however, distinguish itself from near-neighbors such as tool_output_firewall or mcp_sampling_guard, so sibling differentiation is left to the agent.

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

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

'Pre-execution' clearly places the tool in the workflow, implying it should be called before running a payload. Beyond that temporal hint, there is no statement of when not to use it and no named alternative among the many overlapping security siblings, so usage is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds a genuinely useful non-schema trait: the tool itself costs 60 sats via L402, which matters for an agent budgeting payments. It does not disclose output shape, failure modes, or how verification results are reported.

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

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

A single front-loaded sentence with no filler; the tool's identity and cost are stated up front. The nested acronym list is dense but earns its space by naming supported protocols.

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 carries the burden of explaining what a verification returns (pass/fail? risk score? invoice details?) and it does not. Combined with 0% parameter coverage, an agent knows the purpose but not the inputs or the result contract.

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

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

Schema description coverage is 0% for both parameters. The description never explains what www_authenticate_header should contain (raw header value? parsed challenge?) or what advertised_max_sats is compared against. '60 sats' is the tool's own fee, not a hint about advertised_max_sats semantics, so the description fails to compensate for the coverage gap.

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

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

States a specific verb (audit/verify) and resource (HTTP 402 / L402 / x402 / MPP challenges and BOLT11 invoices), which distinguishes it from siblings like mpp_deep_search or mev_risk. The dense parenthetical is understandable but the 'fraud auditor' framing is the only clue to what the verdict actually means.

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 'Pre-payment' prefix implies the use case (run this before paying a 402 challenge), but no alternative tool is named and no when-not-to-use condition is given. Usage must be inferred rather than read.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered by structured data. The description's one real contribution is the L402 payment requirement (50 sats), which is behavioral context an agent cannot get from annotations or schema. It still omits what happens on unrepairable input or partial repairs, keeping it at a middling score.

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

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

One compact sentence, front-loaded, with no filler clauses. Points off only because "Autonomous" and "healer" are ornamental rather than informative, spending words without adding selection value.

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

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

For a single-input, annotation-rich tool this is close to adequate, but with no output schema the description should say that it returns the repaired JSON and what indicates a failed repair. Given the payment requirement and openWorldHint, an agent also cannot tell whether the repaired payload or a receipt is returned.

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 ("Malformed JSON string"), so the schema already carries the semantics. The description adds no format, size, or encoding guidance beyond the schema, so the baseline 3 for high-coverage schemas applies.

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

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

The description names a specific resource (malformed JSON) and the operation (syntax repair), which is enough to separate it from siblings like regex_oracle or code_sandbox. However, the framing leans on marketing language ("autonomous healer") rather than a precise verb such as "repairs," and it never states what it returns, so it falls short of the 5-tier crispness.

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

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

There is no statement of when to reach for this tool versus alternatives, no prerequisites, and no exclusions. The only contextual cue is the price tag (50 sats via L402), which tells the agent calling has a cost but not when it is the right choice.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact not in the annotations: an L402 payment of 85 sats is required. It does not disclose what the diff output looks like or whether the two lists must be from the same session.

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

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

A single front-loaded sentence with no filler, and the pricing constraint is parenthetically attached rather than buried. It is efficient, though the dense compound phrasing ('rug-pull and mid-session schema mutation detector') takes a second read.

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

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

With no output schema and no annotation coverage of return behavior, the description should say what a caller gets back (a list of added/removed/mutated tools? a verdict?) and how to interpret it. Neither the parameters nor the return shape are addressed, leaving the core contract of a diff tool unspecified.

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

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

Schema description coverage is 0% and neither parameter is described in the schema or the description. The agent must infer that baseline_tools_list and current_tools_list are the two snapshots to compare, and nothing explains ordering, format, or whether either may be empty. This is a real gap for a 2-param tool with zero schema documentation.

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

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

The description names a specific resource and operation: detecting MCP tools/list rug-pulls and mid-session schema mutation. No sibling tool does anything comparable, so an agent can distinguish it without opening the schema. It stops short of stating the actual mechanism (comparing two snapshots), which keeps it from a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. The only contextual hint is the price, which tells the agent nothing about when this tool is the right choice versus, say, contract_audit or mcp_sampling_guard.

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, idempotentHint, non-destructive, and openWorld. The description adds genuinely useful context beyond that: this is a security inspection step and it costs 100 sats via L402, which affects whether an agent should call it. It still omits what a verdict looks like or how the request is analyzed.

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

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

One compact sentence, front-loaded with the function and the target message type, with the payment clause appended. Dense with domain jargon but no filler sentences.

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

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

For a security firewall with a nested, undocumented input object, no output schema, and a paid invocation, the description leaves too much unspecified: no return shape, no pass/fail semantics, no note on whether the request is rewritten or merely flagged.

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

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

The single parameter 'sampling_request' is a nested object with 0% schema description coverage and no shape documented anywhere. The description's mention of MCP sampling/createMessage gives a weak hint about what belongs in it, but the internal structure is entirely opaque.

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

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

The description names a specific resource (MCP sampling/createMessage) and specific threats it guards against (reverse-injection, quota-hijack), which is far more concrete than a generic 'guard' label. It implicitly distinguishes itself from siblings like tool_output_firewall, though it never names a sibling directly.

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

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

Usage is implied by the domain: you run this on MCP sampling/createMessage requests. However, there is no explicit when-to-use vs. when-not, no mention of alternatives such as tool_output_firewall or mcp_rugpull_diff, and no stated prerequisites for calling 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 cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the bar is lower. The description adds information the annotations do not: this call is paid, costing 50 sats via L402. That pricing/auth disclosure is genuinely useful for an agent deciding whether to invoke it, though the mechanics of satisfying the L402 challenge are not explained.

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

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

A single front-loaded sentence with no filler. Both the data scope and the price/L402 caveat are packed in without waste.

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

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

With no output schema, the description must carry the return-shape burden. 'Recommended feerates across priority tiers' gestures at the structure but does not name the tiers or units, and the L402 payment flow the agent must complete is left unexplained. Adequate but with clear gaps for a paid data endpoint.

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 (network) with 100% schema description coverage, so the schema already documents its valid values and default. The description never mentions the parameter, so it adds 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 description names a specific resource — live Bitcoin recommended feerates across priority tiers — and implicitly distinguishes itself from the Solana-focused x402_solana_priority_fee_oracle sibling by naming the Bitcoin mempool context. It lacks an explicit verb (e.g., 'Get'), but the data-return purpose is unambiguous for a read-only lookup 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?

There is no statement of when to call this versus alternatives, nor any prerequisite or exclusion. The agent is left to infer that this is the Bitcoin fee source, with no routing guidance relative to x402_solana_priority_fee_oracle or other fee/quota tools.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false), lowering the bar. The description still adds real behavioral context not in the annotations: the 150-sats cost and L402 payment flow, which the agent must know before invoking. It does not disclose return format, though no output schema exists.

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

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

A single front-loaded sentence with no filler or redundancy. It is tight, though so terse that it leans on brevity at the expense of specification.

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

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

For a 4-parameter tool with 0% schema coverage and no output schema, the one-sentence description leaves critical gaps: token identifier formats, slippage units, and what the risk result contains. The payment note is the only substantive addition, so an agent lacks enough to invoke confidently.

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

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

Schema description coverage is 0% across 4 parameters, so the description carries the full burden for parameter meaning — and it provides none. It says nothing about dex format, token identifier format, or the units/range of slippage_bps, leaving an agent to guess how to populate all inputs.

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

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

States a specific verb+resource+scope: 'Pre-swap MEV sandwich and frontrunning risk auditor.' An agent can distinguish this from solana_risk or contract_audit by domain (MEV/sandwich risk, pre-trade timing). No sibling is named explicitly, 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?

The 'pre-swap' qualifier implies the usage window (run before executing a swap), which is useful implied guidance. However, it names no alternatives, no when-not conditions, and no prerequisites beyond the implicit timing.

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, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is largely covered by structured fields. The description adds genuine behavioral context by disclosing the cost ('$0.15 USDC via MPP'), which the agent needs before invoking. Beyond pricing, it says nothing about auth requirements, failure modes, or what the arbiter produces.

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

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

It is a single fragment rather than a structured sentence, so it is short but not efficient in a useful way. There is no front-loaded statement of action, and the one parenthetical is spent on pricing instead of clarifying the operation. Under-specification, not conciseness.

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

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

For a tool with a nested-object parameter, an array parameter, no output schema, and 0% schema coverage, a single fragment is inadequate. The agent has no way to know what the arbiter evaluates or returns, or how 'assertions' are applied to the deliverable. The pricing aside is the only concrete detail.

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 two required parameters and 0% schema description coverage, the description carries the full burden of explaining parameters but delivers almost nothing. 'Deliverable' and 'Schema' loosely gesture at the 'deliverable' object and 'assertions' array, but there is no indication of expected shape, format, or the relationship between the two. This is a clear compensation gap.

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

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

The description is essentially a restatement of the tool name as a noun phrase ('Multi-Agent Task Deliverable & Schema Escrow Arbiter'), with no verb stating what action the tool performs. It never explains what 'arbitrating' a deliverable against assertions actually means or how it differs from the many agent_* siblings. Without a schema read, an agent cannot tell what this returns or decides.

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

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

There is no explicit when-to-use, when-not-to-use, or named alternative. The phrase 'Multi-Agent Task' faintly implies a task-deliverable context, but no condition tells the agent when to reach for this over agent_schema_enforcer or agent_hallucination_auditor. Guidance is at best implied and unactionable.

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, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds genuinely non-obvious context beyond the annotations: this is a paid call costing $0.10 USDC via MPP on Base, which an agent must know before invoking. It still omits latency/async behavior for a 'deep' research call.

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

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

One compact sentence with no waste, and the core deliverable is front-loaded. It is slightly dense with unexplained jargon ('MPP on Base') that a non-crypto agent may not parse, which keeps it short of a 5.

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 essential payment and read-only facts are present. Missing are any sense of the dossier's structure or length, latency expectations, and how it differs from sibling research tools, which leaves it only minimally complete.

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

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

Schema description coverage is 100% with a single 'query' parameter documented as 'Investigation target'. The description adds no syntax, scope or format detail beyond the schema, so the baseline 3 applies.

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

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

The description states a specific deliverable (a deep research dossier with live citations), which is clearly more than a tautology of the name. It does not, however, distinguish this tool from the sibling web_brief, leaving the agent to guess which research tool applies.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of alternatives. With web_brief sitting right next to it in the sibling list, the absence of any routing hint (e.g. 'use for multi-source dossiers vs. web_brief for quick lookups') is a real gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context in the form of the $0.05 USDC cost via MPP, signaling a paid call, but it says nothing about streaming lifecycle, session semantics, or expected 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?

A single short sentence, front-loaded with the capability and the price. There is no padding, though the terseness leaves the tool under-explained rather than wasteful.

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

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

With only three parameters, one required, no output schema, and annotations covering the safety profile, the definition is minimally sufficient. However, for a streaming/session-based inference tool, the absence of any explanation of what session_id does or what the stream returns is a notable gap.

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

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

Schema coverage is 100%, so model, prompt, and session_id are each documented in the schema, and the description adds no additional meaning such as default model behavior or how session_id continues a stream. Baseline 3 applies when the schema does the heavy lifting.

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

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

The phrase 'Streaming Agent Reasoning & Session Inference' names a capability area but no concrete verb+resource, so an agent cannot confidently tell it apart from siblings like ai_generate, ai_deep_research, or agent_prompt_compiler. It conveys that inference/reasoning is streamed, which is more than a tautology, but the boundaries remain vague.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites beyond the implicit payment, and no exclusion criteria. The agent must infer usage entirely from the name.

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, idempotent, non-destructive, open-world. The description adds genuinely useful behavioral context beyond that: output is ReDoS-safe, results are validated by automated tests, and invocation costs 50 sats via L402 (a paid, metered call). The payment requirement is important and not captured by any annotation.

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

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

A single front-loaded sentence with zero filler; the differentiating property (ReDoS-safe), the validation behavior, and the cost are all packed efficiently.

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

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

For a one-parameter tool whose safety profile is covered by annotations, the description is adequate: it conveys purpose, validation, and the L402 cost, and no output schema means return values need not be explained. However it leaves ambiguity about what the agent must supply (only requirements? example strings?) and how the synthesized pattern is returned, which matters for a paid call.

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

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

Schema description coverage is 100% for the single 'description' parameter, so the schema already carries the parameter documentation and the baseline is 3. The description adds nothing about how to phrase 'Pattern requirements' or whether sample inputs/tests should be embedded.

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

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

Names a specific verb+resource with distinguishing qualifiers: 'ReDoS-safe regex synthesizer' plus 'automated test validation'. An agent immediately knows this generates attack-resistant regex patterns. No sibling tool covers regex synthesis, so the lack of explicit differentiation is not a gap.

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

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

The description states what the tool is but gives no when-to-use guidance, no prerequisites, and no alternatives to prefer or avoid. Nothing tells the agent under what circumstances synthesizing a regex is preferable to writing one directly or validating one elsewhere.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description usefully adds that this is a paid tool (150 sats via L402), which the annotations do not convey, but it says nothing about what redaction produces (masking vs removal), what patterns are detected, or response shape.

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

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

A single front-loaded sentence with no filler; the pricing detail is tacked on in parentheses rather than buried. It is efficient, though arguably too terse given the undocumented parameters.

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 tool with no output schema and only 33% schema coverage, one sentence is inadequate. There is no explanation of the boolean toggles, no indication of what the redacted output looks like, and no mention of the L402 payment flow an agent must satisfy to invoke it.

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

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

Schema description coverage is only 33% — the two boolean toggles (redact_emails, redact_phones) have no schema descriptions, and the description supplies no parameter information at all. With low coverage the description was expected to compensate, and it does not, so the agent learns nothing about the redaction options.

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 function: a redaction engine that removes PII from text inputs. An agent can tell this is a sanitization/redaction tool, though the marketing-style phrasing ('Zero-PII Privacy Redaction Engine') is less precise than a plain verb+resource, and it draws no boundary against siblings like clean_data or tool_output_firewall.

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?

'for untrusted agent inputs' implies the intended context — sanitizing external/untrusted text before use — which is genuine usage guidance. However, it gives no when-not conditions and never names the alternative sanitization tools, so the agent must infer the boundary itself.

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

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

Annotations already declare readOnly, idempotent, open-world, non-destructive. The description adds a genuinely non-obvious behavioral trait: the tool is metered/paid ($0.02 USDC via x402 or 100 sats via L402), which an agent must handle before invoking. It does not describe risk dimensions, scoring scale, 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?

One front-loaded sentence carrying the resource, scope, and pricing, with zero filler. Nothing is repeated from the title or schema.

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

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

No output schema exists, so the description carries the burden of explaining what a 'risk evaluation' returns — score, flags, holder distribution, etc. — and it says nothing about the result shape or what makes a token risky. For a paid analysis endpoint with no return schema, this is a significant gap.

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

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

Schema coverage is 100% and there is a single required parameter whose description ('Solana mint or wallet pubkey') already documents the accepted forms. The description adds no syntax, chain-scope, or validation meaning 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+resource: risk evaluation of Solana SPL tokens and wallets. It is distinguishable from likely neighbors such as mev_risk (MEV-specific) and contract_audit, though it never names a sibling or scoping boundary explicitly.

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

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

No when-to-use guidance, no prerequisites, no alternative routing. The only extra information is payment cost and protocols, which is not usage guidance. An agent learns nothing about when this tool is the right choice.

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/idempotent/non-destructive, so the safety profile is covered. The description adds one genuinely useful behavioral fact beyond them: the 100-sat L402 paywall cost of calling. It does not explain what 'estimation' returns (indicative vs executable rate), rate limits, 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?

A single front-loaded sentence with no filler; the asset scope leads and the payment note trails. It is efficient, though it may be too terse for a tool with unexplained return semantics.

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 should clarify what a 'swap rate' result contains (a number, a quote object, expiry), which it does not. Annotations cover the safety profile, but the return shape and estimation semantics remain 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%, so the baseline is 3, but the schema only says 'Source/Destination asset ticker' with no enum. The description's enumeration of supported assets (BTC, ETH, SOL, SUI, USDC) meaningfully constrains valid from_asset/to_asset values, adding real value over 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 (rate estimation), resource (cross-chain swap), and scope (supported assets BTC, ETH, SOL, SUI, USDC). It's clearly distinguishable from generic siblings like crypto_bridge_quote, though it never explicitly contrasts with them.

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

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

The description offers no when-to-use context, no prerequisites, and no guidance on when to prefer this over siblings like crypto_bridge_quote or x402_solana_priority_fee_oracle. The agent must infer its purpose from the name alone.

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

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

Annotations already cover safety traits (readOnly, idempotent, non-destructive, openWorld), so the description earns credit for adding the L402 payment requirement (75 sats) and the specific detection targets, which the agent would otherwise not know. It does not clarify whether output is mutated in place or returned as a cleaned copy, which is the main remaining gap.

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

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

A single dense sentence that front-loads the detection targets and appends the payment cost. Every element is informative and there is no padding, though the phrasing is compact to the point of being slightly awkward.

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

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

For a 2-parameter tool with no output schema, the description conveys the threat scope and cost but omits what the tool returns and how the cleaned result is delivered. Annotations carry the safety profile, so this is adequate but has clear gaps around return behavior.

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

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

Schema description coverage is 0% and the description explains neither raw_tool_output nor source_tool_name. The names are largely self-explanatory, but the description adds no meaning (e.g., whether source_tool_name changes detection behavior), so it fails to compensate for the coverage gap.

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

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

The description names a concrete function (scrubbing tool output) and specifies the exact threat classes it targets: indirect prompt injection, invisible Unicode (U+E0000), and exfiltration beacons. This is specific enough to distinguish it from generic siblings like guardrail_verify or regex_oracle, though it doesn't explicitly contrast itself with them.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named. The agent can infer it applies to tool output from the phrase 'tool output scrubber', but that is implied usage rather than stated context, so it falls short of a 3.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description's job is to add context, and it does: results are externally grounded with live citations, output is strict JSON, and invocation carries a cost of 200 sats via L402. The payment/auth requirement is the single most operationally important fact here and it is disclosed. It stops short of explaining what happens on payment failure or whether the price is per call.

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

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

One dense sentence with no filler, and the essential facts (grounding, citations, JSON output, price) are all front-loaded. The parenthetical price placement is slightly awkward but costs nothing in 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?

For a single-parameter read-only tool with a 100%-documented schema and annotations covering safety, the main remaining unknowns are the shape of the 'strict JSON' payload and the payment flow (L402 challenge/retry behavior). The description flags that JSON and a price exist but does not characterize either, so it is adequate rather than complete.

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

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

Schema description coverage is 100% and the single 'topic' parameter already carries a definition ('Research query or topic'), so the description meets the baseline. It adds no syntax, format, or constraint 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 deliverable (a grounded real-time market intelligence brief with live Google Search citations) and an output contract (strict JSON), which is far more specific than a tautology. It does not, however, distinguish itself from the nearest sibling, mpp_deep_search, so an agent must guess which research tool to pick.

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

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

There is no when-to-use, when-not-to-use, or alternative routing guidance. The reference to live Google Search and 'market intelligence' only implies a research use case; nothing tells the agent how this differs from its search-like siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds genuinely useful context that the annotations don't: the operation costs $0.01 USDC and is paid via x402. However, it says nothing about how payment is settled, output format, or rate behavior.

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

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

A single tight sentence with no filler; the pricing detail is front-loaded and earns its place. It is appropriately sized for a definition that lacks deeper guidance.

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

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

For a paid, non-annotated-in-detail mutation-free tool with no output schema and an undocumented second parameter, the description omits return shape (vector size linkage to `dimensions`), the x402 payment flow an agent must satisfy, and any sibling differentiation. Significant gaps remain.

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

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

Schema coverage is only 50%: `text` is self-documented but `dimensions` has no description beyond a default of 3072. The description adds nothing about parameter meaning, so it fails to compensate for the undocumented dimension parameter.

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

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

The description identifies the resource (semantic vector embeddings) and that it's an agent-facing embeddings service, but it uses a noun phrase rather than a verb and never differentiates itself from the sibling ai_embeddings tool. An agent can broadly tell what it produces, but not why it would pick this over the near-identical 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?

There is no when-to-use, when-not-to-use, or alternative guidance at all, despite ai_embeddings being an obvious sibling alternative. Usage must be inferred entirely from the name.

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