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

Annotations already cover read-only/idempotent/closed-world, and the description adds behavior beyond them: zero execution or evaluation guarantee, a 32 KB payload limit, 60 RPM rate limit, auth options (?demo=true or L402 20 sats), and HTTP 400 on invalid input. These are operationally actionable traits not present in the annotations.

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

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

Front-loaded with the core purpose and extraction capabilities, then usage routing, then operational constraints. It is dense but each clause carries information; the pricing/auth details are compressed rather than verbose.

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

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

With an output schema present and annotations covering the safety profile, the description needn't explain return values and doesn't. It covers languages, limits, auth, and error behavior; the only residual gap is the minor 'code' vs 'source_text' alias ambiguity.

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 all three parameters and the enum defaults are already documented, making the baseline 3. The description adds the 32 KB size constraint but its mention of 'source_text' as the accepted input is slightly ambiguous since 'code' is the required parameter and the alias relationship is only clarified 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?

States a specific verb+resource ('Static lexer and AST parser') and enumerates exactly what it extracts (imports, exports, classes, interfaces, functions, call edges, McCabe complexity, Halstead volume) plus the supported languages. It explicitly distinguishes itself from the sibling audit_module_dependency_cycles by scoping to intra-file analysis.

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

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

Gives an explicit when-to-use ('mapping internal functions, call graphs, and complexity hotspots of a source file before refactoring') and an explicit alternative with its condition ('for analyzing cross-file import DAGs and circular dependencies, use audit_module_dependency_cycles instead'). Little is left to inference.

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

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

Beyond the read-only annotations, it discloses stateless edge-call behavior, a 32 KB maximum, a 60 RPM rate limit, demo/L402 access with a 30 sats cost, and HTTP 400 on invalid input. These are operationally meaningful constraints not present in the structured annotations.

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

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

The description is front-loaded with the purpose and usage guidance, then adds access and constraint details. It is dense but efficient overall, though the incorrect time_window default reduces the value of one packed 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?

With an output schema present, the description does not need to explain return values, and it covers usage, access, rate limits, and error behavior well. However, the contradictory time_window default means the definition is not fully internally consistent.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds a default for time_window, but it says the default is '1h' while the schema says '24h', creating a harmful contradiction rather than useful clarification.

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 and resource: analyzing on-chain EVE Frontier killmail.move events to quantify gatecamp ambush probability and identify hostile hull doctrines. This is clearly distinguishable from sibling tools such as prioritize_eve_turret_targets.

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 explicitly says when to use it: assessing solar-system PvP danger before jumping a hauler or fleet. It also names an alternative tool and the condition selecting that alternative: real-time weapon target-lock priorities during active grid combat.

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 readOnly/idempotent/non-destructive, but the description goes further with concrete operational facts: stateless edge call, 32 KB payload cap, 60 RPM limit, demo mode, L402 payment of 15 sats, and HTTP 400 on invalid input. This is real behavioral value beyond the annotations, though it doesn't describe response content or partial-failure behavior.

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

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

The purpose and alternative routing are front-loaded, and the operational details are compressed into one sentence with no filler. It is dense and slightly technical, but each clause (limits, payment, error code) carries usable 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?

An output schema exists, so return-value detail is unnecessary; the description covers inputs, defaults, size/rate limits, payment requirements, and error signaling. For a stateless read-only call this is sufficient for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds extra meaning: it names text_or_headlines as the accepted input and supplies the default for sentiment_domain ('general_news'), which is not stated in the schema. It does not clarify entity_filter behavior, so it stops short of a 5.

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 (evaluates) applied to a concrete resource (sentiment across news headlines, discussions, articles) with an explicit output shape (bull/bear polarity scores). It also names the sibling it is not, so an agent can distinguish it from compile_competitive_landscape without opening either schema.

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

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

Explicitly gives use cases (market sentiment, social brand perception, controversy exposure on specific entities) and names the alternative tool plus the condition that selects it (competitive market comparisons). Nothing is left to inference.

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

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

The description contradicts the openWorldHint=false annotation: it describes tracking breaking news feeds and external market catalysts, which inherently involve open-world external entities. Despite otherwise rich behavioral details (rate limit, payment, error codes), the direct contradiction with structured annotations forces a score of 1 per the rubric.

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

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

The description is front-loaded with purpose, then usage guidance, then technical constraints. Every sentence adds value: the first defines the tool, the second routes the agent, and the third provides operational details (size limit, rate limit, payment, error behavior) 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?

Given the output schema, complete parameter documentation, and annotations, the description fills all remaining gaps: it covers purpose, usage, alternatives, rate limits, authentication, size constraints, and error behavior. An agent can invoke the tool confidently based on this definition.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds useful semantics: it states the default for recency_window ('past_24_hours') and mentions '?demo=true' and L402 payment options not present in the schema. It does not elaborate on sentiment_cluster beyond the schema, keeping it from a 5.

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

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

The description states a specific verb and resource: tracks breaking news feeds, clusters trending story cycles, and calculates publication velocity. It explicitly names the sibling analyze_media_sentiment and distinguishes its own purpose from sentiment polarity evaluation.

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

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

It gives explicit when-to-use conditions (breaking market catalysts, emerging controversies, product announcements) and names the alternative tool for sentiment analysis. This is exactly the routing guidance an agent needs.

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?

Beyond the annotations (readOnly, non-destructive, idempotent), the description discloses statelessness, a 32 KB payload ceiling, a 60 RPM rate limit, the '?demo=true' and L402 (100 sats) access paths, and the HTTP 400 failure mode. Those are exactly the operational facts an agent needs and none are in the structured fields.

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

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

Front-loaded with purpose and the sibling routing rule, then the operational constraints. It is dense and slightly runs-on in the final parenthetical clause, but every sentence carries information that is not duplicated elsewhere.

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 output schema, the return values need no explanation. Combined with the auth/payment path, rate and size limits, and error behavior, nothing material is missing for correct invocation.

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

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

Schema description coverage is 100% and the enum is documented in-schema, so the baseline is 3. The description only restates the 'modality_focus' default and the nature of 'input' without adding format or syntax guidance beyond the schema.

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

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

States a specific verb (analyzes) plus the exact resource (combined multimodal prompts spanning text, image descriptors, audio transcripts, and video temporal events) and names the underlying model. It also distinguishes itself from the sibling generate_gemini_completion, so an agent can route without opening either schema.

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

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

Explicit when-to-use ('correlating information across multiple media modalities in a single reasoning pass') and an explicit when-not with the named alternative ('for running pure text-only reasoning or coding prompts, use generate_gemini_completion instead'). Nothing is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds real operational context: stateless edge call, 32 KB payload cap, 60 RPM rate limit, L402 payment of 15 sats, demo mode, and HTTP 400 on invalid input. The only gap is that payment/demo mechanics are described as query-string behavior not reflected anywhere in the input schema, which could confuse an agent about how to supply them.

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

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

Two sentences, front-loaded with purpose before the alternative and the operational constraints. The second sentence is a dense run-on cramming size limit, rate limit, parameter default, payment scheme, and error code together, which costs some scannability but no sentence is 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 an output schema present, return values need not be explained. The description covers purpose, routing to the sibling, parameter default, resource limits, auth/payment, and error behavior — everything an agent needs to call it correctly. Only the demo/payment mechanism lacks a corresponding schema field.

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

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

Schema coverage is 100%, so baseline is 3; however the description adds a fact the schema omits — that 'optimization_target' defaults to 'eliminate_seq_scans' — which is genuinely useful for deciding whether to pass the argument. It adds no meaning for 'explain_plan_or_query' or 'database_engine' 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?

Specific verb + resource: 'Analyzes SQL EXPLAIN execution plans to detect sequential table scans, high-cost cartesian joins, and buffer memory bottlenecks.' This names the exact artifacts it detects, so an agent can distinguish it from siblings like audit_sql_injection_ast or validate_sql_query_ast without opening any schema.

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

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

Gives explicit triggering conditions ('diagnosing slow queries, optimizing database performance, or evaluating query cost') and names the alternative with the condition that selects it ('for getting index recommendations, use recommend_database_indexes instead'). Nothing about routing is left to inference.

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

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

Annotations already establish read-only, non-destructive, idempotent behavior, and the description adds operational context beyond that: 32 KB size, 60 RPM, demo/L402 payment handling, and HTTP 400 on invalid input. It also discloses the matching mechanism and bracket-balance verification, which helps the agent anticipate behavior.

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

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

The description is compact and front-loads the purpose before usage guidance and operational constraints. The final sentence is dense and packs several details into semicolons, and the phrase 'with enum defaults' is slightly compressed, but there is little waste.

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

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

Given rich annotations, a fully described schema, and an output schema, the description supplies the remaining context an agent needs: what the tool does, when to select it, the alternative, operational limits, and error behavior. Nothing important for correct invocation appears to be missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description mentions 'original_code' and enum defaults, but this adds little beyond the schema and is slightly vague about which parameter actually has the enum default.

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

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

The description states a specific verb and resource: applying unified diffs or SEARCH/REPLACE blocks to source code. It also explains the core mechanism and explicitly contrasts itself with analyze_ast_symbol_graph for non-modifying code inspection, so the tool is distinguishable from siblings 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?

It gives a clear trigger for when to use the tool: healing and applying code edits or diffs that failed exact line matching because of line-number drift or whitespace differences. It also names the alternative tool for signature, call-tree, and complexity inspection, making the decision boundary explicit.

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 read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is largely covered and the description's "Read-only call" restates it. It does add real value beyond annotations: a 32 KB payload ceiling, 60 RPM rate limit, auth options (?demo=true or MPP at 30 sats), and a 400 response on invalid input. Those operational limits are useful, but the return shape and how partial criteria satisfaction is reported are left unstated. With annotations carrying the behavioral baseline, this is solid added context rather than a full disclosure.

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

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

Front-loaded with the verdict-producing action and the three outcomes, then routing guidance, then operational constraints, so the most decision-relevant content comes first. It is one dense block with every clause carrying information (limits, pricing, error code), though the run-on cramming of transport/auth/limits reduces scannability slightly.

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

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

For a read-only arbitration tool with a full schema, an enum-bearing standard, and an output schema, the description covers purpose, routing, budget limits, rate limit, auth method, and error behavior. Since an output schema exists, it need not explain the returned verdict structure, so no decision-relevant gap remains.

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 all three parameters and the arbitration_standard enum are already documented in the schema, which sets the baseline at 3. The description's parenthetical "accepts 'deliverable' (with enum defaults)" is slightly muddled since deliverable is a plain string and the enum belongs to arbitration_standard, adding no real semantics. The terms default and standard default are already in the schema, so the description neither compensates nor detracts materially.

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 (evaluates), resource (worker agent's submitted deliverable), comparison basis (contract acceptance criteria), and the exact outcome (deterministic escrow verdict) with all three verdict values spelled out. It also explicitly contrasts with the nearest sibling, enforce_json_schema_types, so the agent can distinguish the two without opening a schema.

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

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

Gives both sides of the routing decision: use when settling multi-agent bounties or verifying subcontractor deliverables before releasing MPP/L402 escrow funds, and use enforce_json_schema_types instead when only syntactic JSON Schema property types matter. It even notes the exclusion is about not evaluating semantic contract terms, which is the exact boundary an agent needs.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds operational details beyond that: stateless edge call, 32 KB limit, 60 RPM, demo/L402 access, and HTTP 400 on invalid input. These are exactly the behavioral constraints an agent needs before invoking the tool.

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

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

The description is front-loaded with purpose, then usage, then operational constraints. Each sentence contributes necessary information, and there is no redundant restatement of the tool name or title.

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

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

With only two fully documented parameters, an output schema, and annotations covering safety profile, the description is complete enough for correct invocation. It covers use cases, alternatives, rate/size limits, payment/demo access, and error 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 100%, so the schema already documents tribe_id and the standing_filter enum. The description only repeats the default value for standing_filter and adds no further parameter semantics beyond the structured 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 opens with a specific verb and resource: auditing EVE Frontier Tribe diplomatic standings, reputation scores, and pilot override entries. It clearly distinguishes this read/audit tool from the sibling that compiles standings into Sui Move ACL bytecode.

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

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

It explicitly states when to use the tool: checking diplomatic relations or detecting conflicting friendly-fire rules. It also names the alternative compile_eve_gate_acl for the adjacent compilation task, which gives the agent a clear routing decision.

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?

Beyond readOnly/idempotent/non-destructive annotations it discloses statelessness, a 32 KB payload cap, 60 RPM rate limit, payment options (demo=true or L402 at 25 sats), and the HTTP 400 failure mode for invalid input. These are operational traits the annotations cannot express and materially affect how an agent calls it.

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

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

Front-loads purpose, then routing, then operational constraints — a sensible order with no filler sentences. The final clause is dense (size, rate, auth, error all in one line), which slightly hurts scannability but 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 2-param read-only audit tool with an output schema, the description covers purpose, alternative routing, payload limits, auth/payment, and error behavior — everything needed to invoke it correctly. Nothing material is missing.

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

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

Schema coverage is 100% and the audit_profile enum is fully documented, so the schema carries most weight. The description still adds value by noting manifest_json accepts a JSON string or object form and that audit_profile 'defaults to strict', reinforcing default behavior beyond the enum list.

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

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

States a specific verb (Scans) and resource (external MCP server's initial tools/list manifest), and names the exact threat classes detected (tool-name shadowing, hidden prompt-injection directives). It explicitly distinguishes itself from the closest sibling detect_mcp_schema_rugpull, so an agent can route without opening either schema.

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

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

Gives an explicit when-to-use condition (vetting a newly discovered third-party MCP server before mounting) and an explicit when-to-use-the-other condition (comparing a pinned baseline against a live mid-session tools/list → detect_mcp_schema_rugpull). Alternatives and exclusions are both named.

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

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

While annotations cover read-only status, the description provides critical operational context beyond structured data, including rate limits (60 RPM), payload size (32 KB), error handling (HTTP 400), and the underlying algorithmic approach.

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 tool definition is extremely dense, but every piece of information serves a purpose: describing the function, the use case, the alternative, and the operational constraints.

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?

The description provides a complete picture of the tool's scope, mechanism, and limits, making it highly reliable for an agent to invoke it correctly without needing external documentation.

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 100% schema coverage, the baseline is high. The description adds semantic value by specifying that the input is a mapping of module names to import arrays (an 'import map'), providing structure context that complements 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 provides a highly specific technical explanation, naming the algorithms (Tarjan's SCC) and the resource it operates on (module import maps) to detect specific, complex issues like circular dependencies and blast radius.

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

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

It clearly delineates the correct use case (auditing multi-file import graphs) and explicitly directs the agent away from the correct alternative sibling tool ('analyze_ast_symbol_graph') for single-file analysis.

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 read-only/idempotent/non-destructive, and the description adds operationally important traits those annotations cannot express: a 32 KB input ceiling, 60 RPM rate limit, HTTP 400 on invalid input, and a payment/demo access mode (L402, 15 sats). This is exactly the added context the dimension rewards.

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

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

Front-loaded with the core purpose in the first clause, then usage, then operational constraints — a sensible information order. It is dense and slightly crammed with parentheticals, but nearly every clause carries actionable 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?

An output schema exists so return values need no explanation, and the description still covers invocation preconditions, limits, error signaling, and payment handling. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100% and it documents both parameters and the enum, so the baseline is 3. The description adds value by restating the egress_policy default and, more usefully, disclosing a '?demo=true' / L402 access mechanism that appears nowhere in the input 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 ('static validation firewall') and a precise resource ('outbound network destination URIs') plus the exact threat classes blocked (169.254.169.254, RFC 1918, query-string secrets). It explicitly names the sibling it is not (verify_agent_command_safety), so an agent can distinguish it without opening schemas.

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

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

Gives an explicit trigger ('Use when validating a user-supplied or tool-supplied URI destination before network dispatch') and an explicit exclusion routing to verify_agent_command_safety for local shell commands or general prompts. Both when-to-use and the alternative are stated.

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

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

The annotations already establish the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real operational context: a 32 KB payload cap, 60 RPM, a stateless edge call, L402 payment of 25 sats or '?demo=true', and an HTTP 400 on invalid input. The one flaw is the claim that "'context' defaults to 'standard'", which is misleading, because the schema marks context as required and no such default 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?

The tool's purpose is front-loaded in the first sentence, followed by usage, the sibling exclusion, and constraints. The final sentence crams four unrelated facts (size cap, rate limit, payment, error code) into one clause, but there's no filler.

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

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

Given that an output schema exists, the description needn't explain return values, and it covers the operational envelope (limits, auth/payment, failure mode) that an agent needs before calling. The gaps are the undocumented strictness parameter behavior and the inaccurate 'context' default, both of which an agent would rely on.

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 each of the three parameters is already documented in the schema, and the baseline of 3 applies. The description restates parameter purpose loosely and introduces a default for 'context' that contradicts the required list, but it never touches the 'strictness' enum (exact_entailment / semantic_paraphrase / citations_only), which is where added semantics would have mattered most.

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

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

The description gives a specific verb and resource: cross-references factual claims, numbers, and citations in a draft response against retrieved source passages and flags hallucinations. That is far more concrete than the name alone. It only differentiates itself from one sibling (sanitize_tool_output_stream) and says nothing about the near-identical sibling verify_factual_claims, so an agent can't fully separate the two from this 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?

It states an explicit trigger ('before returning it to the user' / 'before delivery') and names an alternative with the condition that selects it: use sanitize_tool_output_stream for prompt-injection and invisible Unicode scrubbing. However, the closest alternative, verify_factual_claims, is never mentioned, leaving the most likely routing ambiguity unresolved.

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, closed-world), and the description adds operational traits an agent could not infer: 32 KB input ceiling, 60 RPM limit, demo-mode flag versus L402 payment of 45 sats, and HTTP 400 on invalid input. That is exactly the kind of context annotations cannot express.

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 paragraph, front-loaded with purpose and the sibling routing rule. The pricing/rate-limit clause is crammed into the same sentence and slightly blurs the scan, but no sentence is wasted.

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

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

For a two-parameter read tool with an output schema, rich annotations, and 100% schema coverage, nothing needed for correct invocation is missing: scope, exclusions, cost model, rate limit, and failure mode are all 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 coverage is 100%, so baseline is 3; the description modestly adds value by restating the 'chain' default and the accepted forms of 'code_or_address' (source, ABI, or address), which clarifies that an address is valid input. It does not enumerate the enum values beyond the schema, so it stays a step short of full marks.

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

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

Specific verb ('Statically audits') plus concrete resource ('Solidity, Vyper, or Move smart contract source code') and an enumerated threat list (honeypot transfer taxes, hidden mint backdoors, proxy upgrade traps, reentrancy). It also explicitly carves itself out from the sibling scan_solana_cpi_reentrancy, so an agent can disambiguate without opening schemas.

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

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

States the trigger ('before deploying or interacting with a protocol') and names the exact alternative with the condition that selects it ('for scanning Solana Anchor/Rust programs... use scan_solana_cpi_reentrancy instead'). Both when-to-use and when-to-use-something-else are explicit.

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 readOnly/idempotent/non-destructive/closed-world, yet the description still adds material facts an agent cannot get elsewhere: stateless edge call, 32 KB input cap, 60 RPM rate limit, HTTP 400 on invalid input, and that either 'demo=true' or an L402 payment of 10 sats is required. That is exactly the beyond-annotation context this dimension rewards.

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

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

Front-loaded with purpose, then routing, then operational constraints in a single dense paragraph with no filler sentences. It is packed tightly enough that the payment/rate-limit clause reads as a run-on, 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?

An output schema exists, so return values need no prose; annotations carry the safety profile; the description supplies the remaining operational facts (size limit, rate limit, auth/payment gate, failure mode). Nothing an agent needs before calling is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does add one genuinely new fact – that 'audit_sensitivity' defaults to 'strict_zero_dynamic_taint' – but leaves 'allow_comments' entirely unmentioned, so the gain over the schema is marginal.

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?

Uses a specific verb and mechanism ('statically parses SQL queries via AST lexical analysis') and names the exact vulnerability classes detected: second-order injection, tautology conditions, stacked queries. An agent can distinguish this from summarize_sql or sanitize siblings 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?

Explicitly states the trigger condition ('auditing dynamic query parameters or untrusted user input before database execution') and names an alternative for the adjacent-but-different job ('for sanitizing query strings for telemetry logging, use sanitize_sql_telemetry instead'). It does not address the closest sibling, validate_sql_query_ast, so the routing guidance is good but not exhaustive.

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

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

Goes well beyond the annotations, which only declare readOnly/idempotent/non-destructive/closed-world. The description adds statelessness, a 32 KB payload cap, a 60 RPM rate limit, demo-mode and L402 (15 sats) payment paths, the default isolation level, and a 400-on-invalid-input failure mode — all operationally decisive for an agent orchestrating the 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?

Three sentences, front-loaded with the purpose before the alternative and the operational constraints. The middle sentence is heavily parenthetical (nested quotes around parameter names plus payment/rate-limit clauses), which slightly hurts scannability but every clause carries real 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?

An output schema exists, all three parameters are documented, annotations cover the safety profile, and the description supplies limits, auth/payment mode, defaults, and error behavior. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by disclosing that target_isolation_level defaults to 'read_committed', a default the schema does not state. The remaining parameters, notably strict_deadlock_check, are left entirely to the schema, so it stops short of full compensation.

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

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

States a specific verb (audits) and resource (database transaction workflows) with enumerated failure modes: concurrency anomalies, dirty reads, non-repeatable reads, deadlock risks. It also explicitly names the sibling it is not (calculate_pool_headroom), so an agent can discriminate without opening either schema.

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

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

Gives concrete triggering contexts (financial transfer procedures, inventory decrement operations, multi-step checkout workflows) and routes the connection-pool-headroom case to calculate_pool_headroom. Clear positive guidance and one explicit exclusion, though no general statement of when this tool is inappropriate (e.g., non-transactional SQL review, which might belong to validate_sql_query_ast or analyze_query_plan).

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), yet the description adds real operational context: stateless edge call, 32 KB payload cap, 60 RPM limit, `?demo=true` or L402 payment at 10 sats, and HTTP 400 on invalid input. These are traits an agent cannot get from the annotations and that affect how it should call and retry the tool.

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

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

Two sentences, front-loaded with purpose and alternative routing before the operational constraints. Every clause carries information (cost, rate limit, error behavior); nothing is redundant with the title or restates structured fields.

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

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

Since an output schema exists, return values need no explanation, and the description covers the remaining agent needs: inputs, default behavior, rate/size caps, payment option, and error response. Nothing required to invoke it correctly is missing.

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

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

Schema coverage is 100%, so baseline would be 3, but the description adds meaning beyond the schema by naming the default value for workload_profile ('high_concurrency_oltp'), which the schema does not state. It also frames server_ram_mb and max_concurrent_clients as the two accepted inputs, reinforcing their roles.

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 ("Calculates") applied to concrete outputs: pool sizing, idle timeouts, and client headroom, derived from server RAM and concurrency profile. It also names the sibling audit_transaction_isolation as the tool for a different concern, so an agent can separate the two without opening either schema.

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

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

Gives an explicit use condition (sizing PgBouncer, HikariCP, or Prisma pools to avoid OOM crashes) and an explicit exclusion routing the agent to audit_transaction_isolation for isolation hazards. Nothing about when to pick this tool is left to inference.

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

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

Goes well beyond the annotations (which already establish readOnly/idempotent/non-destructive) by disclosing statelessness, a 32 KB payload cap, a 60 RPM rate limit, the '?demo=true' and L402 (20 sats) access paths, and the HTTP 400 failure mode. These are operational traits an agent cannot infer from structured fields.

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

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

Three tight sentences, front-loaded with purpose before usage and then operational constraints; nothing is repeated from the annotations. Slight density cost from bundling rate limit, payment scheme, and error code into one sentence, but each clause carries distinct 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 stateless two-parameter read with an output schema (so return shape need not be described), the description covers access modes, limits, and failure behavior adequately. The only real gap is the muddled statement about the amount default, which leaves a caller unsure of the exact fallback value.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description's parenthetical 'amount' defaults to 'standard'' conflicts with the schema, which documents 'defaults to 100 when omitted'. That is confusing rather than additive, and 'standard' is not a value in the numeric amount domain; the only real gain is naming the 'currency' argument.

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 ('Calculates') and resource ('instantaneous spot exchange rates and equivalent USD, BTC, and satoshi values'), and enumerates the supported assets. It also explicitly names the sibling it is not (compare_crosschain_bridge_routes), so an agent can disambiguate without opening either schema.

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

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

Gives a concrete when-to-use trigger ('converting a token amount into USD or satoshis for invoice pricing or accounting') and an explicit alternative with its own condition ('for quoting executable non-KYC cross-chain bridge routes... use compare_crosschain_bridge_routes instead'). Both the positive and negative selection cases are covered.

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?

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses that the call is stateless, capped at 32 KB and 60 RPM, supports a '?demo=true' free path or L402 payment of 15 sats, and returns HTTP 400 on invalid input. Rate limits, auth/billing paths and error behavior are exactly the operational context annotations do not carry.

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

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

Three sentences, front-loaded with the operation list before usage routing and then operational constraints — the ordering matches how an agent decides. The final sentence is dense with limits, auth and error codes, but each clause is load-bearing rather than filler.

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

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

An output schema exists, so return values need not be described, and the description supplies everything else material for a stateless 2-parameter tool: size cap, throughput cap, payment path and failure mode. The only completeness defect is the default-value conflict, which undercuts an otherwise thorough definition.

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

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

Schema coverage is 100%, so a 3 would be the baseline, but the description asserts 'normalization_mode' defaults to 'exact_match' while the schema explicitly states it defaults to 'case_insensitive_trim'. For an agent choosing whether to pass the parameter, that conflicting statement is actively misleading and worse than silence.

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

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

The first sentence names four specific operations (dedupe, Unicode whitespace normalization, HTML/control stripping, tabular/JSON canonicalization) against concrete inputs (lines, records, CSV rows, JSON arrays). It is unambiguously distinguishable from nearby siblings like extract_clean_markdown or heal_malformed_json.

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

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

It gives explicit trigger conditions ('noisy scraped lists, CSV rows, or duplicate log lines before indexing or analysis') and names the alternative plus the condition that selects it ('for extracting typed JSON fields from free-form prose paragraphs, use extract_structured_json_entities').

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=false. The description adds real operational context beyond that: statelessness, 32 KB payload cap, 60 RPM rate limit, demo/L402 payment of 15 sats, and a 400 on invalid input. That said, it never describes what the response shape or error payloads look like beyond the status code, so it sits at a solid but not maximal level.

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

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

Two sentences, front-loaded with the purpose before the exclusion and the operational parenthetical. Slightly dense with pricing/rate-limit details packed into one clause, but no sentence is wasted.

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

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

With an output schema present, return values need no explanation. The description covers cost model, rate limit, size cap, default algorithm, error status, and the alternative tool — everything an agent needs to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description still adds value by disclosing that clustering_method defaults to 'tf_idf_semantic_graph' and that the input is subject to a 32 KB limit, neither of which is in the schema. These are small but genuine clarifications beyond the structured data.

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: 'Discovers latent thematic clusters, subtopic branches, and conceptual relationships across document corpora.' It also names the sibling it is not for (summarize_temporal_timeline), so an agent can separate clustering from chronology without opening schemas.

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

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

Gives explicit use cases ('structuring broad search results into distinct thematic silos or generating table of contents taxonomies') and an explicit exclusion routing to summarize_temporal_timeline for chronological milestones. Nothing is left to inference about when to pick 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 declare readOnly, idempotent, non-destructive, and closed-world behavior, and the description adds substantial context beyond that: stateless edge call, 32 KB max, 60 RPM limit, demo mode or L402 payment (20 sats), and HTTP 400 on invalid input. It also clarifies that from_asset is the required input and to_asset defaults to BTC_NATIVE.

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

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

Two dense sentences with no wasted words. The comparison scope and differentiator are front-loaded ahead of operational details, so the agent gets the key routing decision first.

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 an output schema, 100% parameter coverage, and rich annotations, the description fills the remaining gaps: target use case, alternative tool, access/payment model, rate limits, and error behavior. Nothing an agent needs to select or invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no parameter detail in the description. The description does mention from_asset and to_asset defaults, but that information duplicates what the schema already documents; it does not add new semantics such as amount formatting or enum constraints.

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 ('Compares') plus the exact resource (non-KYC cross-chain swap routes across THORChain, Maya, and Liquid) and the metrics compared (bp fee, net output sats, settlement time). It also explicitly distinguishes itself from the sibling calculate_spot_swap_rate, so an agent can tell them apart without opening either schema.

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

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

Gives an explicit use case ('routing cross-chain treasury settlements, e.g. Solana USDC or Base ETH into native Bitcoin') and names the alternative tool with the condition that selects it ('for calculating mid-market spot exchange rates without bridge routing fees, use calculate_spot_swap_rate instead'). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial context they don't carry: stateless edge call, 32 KB payload cap, 60 RPM rate limit, demo mode or L402 payment of 25 sats, and an HTTP 400 failure mode on invalid input. That is exactly the operational detail an agent needs before invoking.

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

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

Purpose and routing come first, with operational constraints trailing — good front-loading and no filler sentences. The final sentence is a dense run-on packing rate limits, payment, and error codes together, which slightly hurts scanability.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. Combined with the stated rate limits, size cap, payment path, and default framework, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3; the description earns extra by disclosing the default value of 'analysis_framework' ('feature_and_pricing_matrix'), which the enum schema does not state. It also names the required parameter, though max_competitors is left entirely to the schema.

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

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

States a specific verb (compiles) plus the concrete artifacts produced: comparison matrices, pricing tiers, feature coverage, and moat evaluations. It explicitly contrasts itself with compile_research_dossier, so an agent can distinguish the two without opening either schema.

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

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

Gives three concrete triggering scenarios (market landscape analysis, pricing parity, competitive diligence) and names the alternative tool for the adjacent task (narrative research briefs). Both the when-to-use and when-not-to-use sides are covered.

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 the description goes well beyond them: stateless edge call, 32 KB payload cap, 60 RPM rate limit, demo mode vs L402 (30 sats) payment, and HTTP 400 on invalid input. These are exactly the operational traits an agent needs to avoid failed or throttled calls.

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

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

Front-loaded with purpose, then usage, then operational constraints — a sensible ordering with no filler sentences. The final clause packs several constraints (size, rate, auth, error code) into one long sentence, which is dense but each element is load-bearing.

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

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

With an output schema present, return values need not be described, and the description still covers everything else an agent needs: statelessness, size limit, rate limit, authentication options, and error behavior. For a two-parameter compiler call this is complete.

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

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

Schema coverage is 100%, with the enum and defaults already documented, so the schema carries the semantic load. The description only restates the 'toll_mode' default ('standing_tiered') and that 'gate_assembly_id' is accepted, adding no new meaning such as identifier format or how toll_mode interacts with standings. 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 ('Compiles') plus three concrete resources (Tribe ACLs, diplomatic standings, surge-pricing toll rules) and names the exact output artifact (Sui Move Smart Gate AccessPolicy constraints). It explicitly distinguishes itself from the nearest sibling, plan_eve_gate_route, so an agent can select between them without opening either schema.

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

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

Gives an explicit when-to-use clause ('configuring on-chain jump permissions and LUX/SUI toll schedules for a player-owned Smart Gate') and an explicit when-not/alternative clause routing route-planning queries to plan_eve_gate_route. Both the positive and negative selection conditions are stated.

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

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

Annotations already cover readOnly/idempotent/openWorld/non-destructive, yet the description adds genuinely new operational facts: stateless edge call, 32 KB response cap, 60 RPM limit, 300 sats MPP pricing, '?demo=true' bypass, and HTTP 400 on invalid input. That is exactly the beyond-annotation context the dimension rewards.

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

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

Two tightly packed sentences that front-load purpose, then routing, then operational limits. Nothing is truly wasted, but the run-on density (pricing, rate limit, size cap, error code in one breath) makes it slightly harder to scan than necessary.

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

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

An output schema exists, so return values needn't be explained, and the description still covers cost, limits, error behavior and the alternative tool. The one material gap is the mismatched parameter naming and default value, which leaves an agent unsure whether to send 'query' or 'research_topic' and what default applies.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description introduces conflicting facts: it says 'output_density' defaults to 'concise_5_points' while the schema says 'executive_10_points', and it presents 'research_topic' as an accepted input while the schema's required field is 'query'. Those mismatches actively mislead rather than add 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?

A specific verb ("Compiles") plus a well-defined resource ("structured JSON research dossier") with the returned fields named inline ('key_findings', 'synthesis_quality_score', 'sources_cited'). It also names the sibling it is not (conduct_deep_research_investigation for L402 narrative reports), so an agent can separate the two without opening either schema.

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

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

Explicit when-to-use ("generating a strict-JSON cited intelligence brief paid via Base USDC MPP session headers") paired with an explicit alternative and the condition selecting it (L402 long-form narrative → conduct_deep_research_investigation). Payment mode and demo-mode fallback are also stated, leaving little 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 readOnly/idempotent/non-destructive/closed-world, yet the description adds substantial operational context beyond them: 32 KB payload cap, 60 RPM throttle, '?demo=true' or L402 payment at 20 sats, and HTTP 400 on invalid input. These are exactly the constraints an agent needs before calling.

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

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

Purpose and output artifacts are front-loaded, then usage, then operational constraints — a sensible ordering with little waste. The second sentence is long and stacks several distinct concerns (size, rate limit, demo/payment, error code), which slightly hurts scannability.

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

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

An output schema exists, so return values need not be described. Combined with stated inference behavior, the sibling exclusion, size/rate limits, payment path, and error behavior, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so root_name and strictness defaults/modes are already documented, and the baseline is 3. The description's claim that sample_json comes 'with enum defaults' is slightly muddled since the enum lives on strictness, and it adds no syntax or format detail about the sample payload itself — so it neither helps much nor compensates for anything.

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

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

States a specific verb (inspects a sample JSON payload) and a concrete multi-artifact output (TypeScript interfaces, Zod schemas, Pydantic v2 models, JSON Schema Draft 2020-12). It even enumerates the inference heuristics (UUID, ISO-8601, email, int vs float, array item types), so an agent knows exactly what it 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?

Explicitly names the use case ('generating static type definitions and runtime validators in TypeScript and Python from a sample JSON response') and routes the agent away with a named alternative: 'for extracting existing function/class symbols and complexity metrics from source code, use analyze_ast_symbol_graph instead.' Both the when and the when-not are stated.

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

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

Adds substantial context beyond the annotations: stateless execution, 32 KB payload cap, 60 RPM rate limit, the ?demo=true escape hatch, L402 payment of 35 sats, and the HTTP 400 failure mode for invalid input. These are exactly the operational constraints (cost, throttling, failure) that annotations alone cannot convey; note the mild tension with openWorldHint=false for a tool that compiles multi-source external research.

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

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

Two sentences, front-loaded with purpose, then routing, then operational constraints — no filler. The final sentence is over-packed, bundling size cap, rate limit, parameter defaults, payment, and error behavior into one line, but every clause carries real 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?

An output schema exists so return values need no explanation, and annotations plus the description together cover safety, cost, limits, and failure modes. What is missing is disambiguation from the several sibling tools that perform comparable deep-research compilation.

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

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

Schema coverage is 100%, so the schema already documents all three parameters, and the description adds only the research_topic name and the depth_level default ('executive_brief'). target_citations is never referenced in the description, and no extra format or sizing guidance is offered beyond what the schema states.

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

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

States a specific verb+resource ('compiles multi-source factual research briefs') and enumerates the artifacts produced: verified citations, confidence intervals, analytical takeaways. It differentiates itself from one sibling (synthesize_neural_search) but does not distinguish itself from the near-identical conduct_deep_research_investigation or compile_mpp_research_dossier, which an agent could easily confuse it with.

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

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

Explicitly says when to use it ('synthesizing comprehensive intelligence briefings on complex technical, scientific, or market developments') and names an alternative with its selecting condition ('for rapid query search snippets, use synthesize_neural_search instead'). The gap is that it gives no exclusion against the most confusable siblings, which do nearly the same deep-research job.

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 readOnly/idempotent/destructive/openWorld, yet the description still adds non-obvious operational traits: 32 KB payload cap, 60 RPM throttle, L402 payment option (15 sats), demo bypass, and an HTTP 400 failure on invalid input. These are exactly the constraints an agent must know before calling.

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

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

Purpose is front-loaded in the first sentence and every subsequent clause carries information, but the final sentence is telegraphic ('Stateless read-only edge call (max 32 KB, 60 RPM)', 'L402 (15 sats)') and packs several unrelated facts into one dense run-on.

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

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

An output schema covers return values and annotations cover safety, and the description fills the remaining gaps: supported standards, size and rate limits, payment/demo access, and error behavior. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by disclosing that 'feed_standard' defaults to 'rss_2_0', a default not stated in the schema. The remaining parameter mentions (items_json contents) merely restate 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?

Names a specific verb (transforms) and both input and output resources (JSON item collections / article card arrays → RSS 2.0, Atom 1.0, JSON Feed 1.1). It also names the sibling it is not (crawl_sitemap_urls) so an agent can route without opening either schema.

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

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

'Use when syndicating blog articles, product announcements, or changelog cards to RSS readers and AI agents' gives concrete positive triggers, and the sitemap clause explicitly excludes the nearest alternative. Both when-to-use and when-not-to-use are present.

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 the description adds real operational context the annotations don't carry: statelessness, a 32 KB payload cap, a 60 RPM rate limit, and a 400 response on invalid input. It loses a point because the '?demo=true or L402 (20 sats)' detail describes an HTTP transport affordance that has no corresponding schema parameter, leaving the agent unsure how to actually trigger it via this tool 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?

The core verb+resource is front-loaded, followed by usage routing and then operational constraints — a sensible order with no filler sentences. It is dense to the point of being crammed into three semicolon-chained clauses, which slightly hurts scanability but nothing is redundant.

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

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

An output schema exists, so return-value detail is rightly omitted, and the safety/idempotency profile is covered by annotations. What's missing is a hint about output determinism or whether compilation quality depends on upstream model behavior — minor for a compile-and-return tool but the one gap an author would still want covered.

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

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

Schema description coverage is 100% and both parameters are already documented in the schema, including the anthropic_xml_tags default. The description restates the 'task' content and the prompt_style default but adds no syntax, size, or content-shaping guidance beyond what the schema provides, 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 (compiles) and resource (raw task description into an XML system prompt) and enumerates the exact output sections produced (<role>, <context>, <objective>, <constraints>, <workflow>, <output_format>). It also explicitly distinguishes itself from the nearest sibling, route_mcp_workflow_plan, so an agent can differentiate without opening a schema.

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

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

Gives an explicit trigger ('Use when authoring or upgrading a system prompt for an autonomous agent or sub-agent workflow') plus an explicit exclusion with the alternative named ('for mapping a task objective to a concrete sequence of MCP tool calls, use route_mcp_workflow_plan instead'). This is the when/when-not/alternative pattern verbatim.

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?

Beyond standard hints, the description provides critical operational behavior not found in schema or annotations, such as the stateless nature, specific size/rate limits (max 32 KB, 60 RPM), and defined error behavior (returns HTTP 400 if invalid).

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

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

The description is dense and front-loaded, packing both functional and operational data into one paragraph. While highly effective, the sheer volume of technical jargon (KB, RPM, Lyria 3) prevents a perfect 5, though the information is logically ordered.

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 complexity of the tool (music generation, specific edge constraints, and failure modes), the description is exhaustively complete, leaving no critical question unanswered for an agent attempting to use 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?

With schema coverage at 100%, the description meets the baseline for supplemental documentation. It successfully reinforces the default value for the `genre_preset` parameter but does not add semantic value that wasn't already structured.

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 highly specific, naming the output (musical tracks, ambient loops), the mechanism (Google Lyria 3), and the inputs it transforms (genre, tempo, mood prompts). It clearly defines what the tool's specific domain is.

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 tool provides explicit 'when to use' scenarios (musical scores, audio loops) and a direct 'when not to use' instruction by pointing to `synthesize_gemini_speech_audio` as the alternative for TTS tasks.

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

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

Goes well beyond the annotations by disclosing statelessness, a 32 KB payload cap, 60 RPM throttling, '?demo=true' access, an L402 payment requirement (300 sats), and the HTTP 400 failure mode. Annotations already cover readOnly/openWorld/idempotent, so this coverage is strong; the one blemish is that the stated 'depth_tier' default conflicts with the schema, which sows doubt about the stated mechanics.

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

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

Core purpose and the sibling alternative are front-loaded, and each clause carries distinct information. The final sentence is dense — API mechanics, payment, and error semantics compressed into one line — but it is not padded.

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

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

Given an output schema exists, return values needn't be described; the description instead covers operational constraints (size, rate limit, payment, error code) that the structured fields do not. Aside from the default-value discrepancy, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description actively contradicts the schema: it says depth_tier 'defaults to quick_synthesis' while the schema says 'defaults to exhaustive_report when omitted.' For a caller choosing omission vs. explicit tier, this is a costly error rather than harmless redundancy, and no additional meaning is added for the 'input' parameter.

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

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

States a specific verb and resource — an iterative multi-hop investigative research session via Gemini Deep Research Pro producing a cited technical report — and names the sibling (search_gemini_grounded_web) it is not. An agent can distinguish this from the other 13 siblings without opening any schema.

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

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

Explicitly scopes use to 'complex scientific, architectural, or market questions requiring deep multi-hop synthesis' and states the exclusion plus the alternative: fast single-turn fact lookup goes to search_gemini_grounded_web. When-to-use, when-not-to-use, and the fallback are all present.

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?

Beyond the readOnly/idempotent/non-destructive annotations, it discloses payload cap (32 KB), rate limit (60 RPM), statelessness, demo-mode and L402 payment requirement (15 sats), and the 400 error on invalid input — none of which the annotations carry.

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

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

Two sentences, front-loaded with purpose before routing guidance, and the operational facts are packed into a compact clause. Dense but essentially waste-free; only the parenthetical enumeration of limits feels slightly crammed.

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 a 100%-covered schema, an output schema handling return values, and annotations covering the safety profile, the description still supplies limits, auth options, and failure mode. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds a real detail the schema lacks — that filter_criteria defaults to 'all_entries' — and names sitemap_xml as the accepted input. It does not, however, explain max_results semantics beyond the schema's own text.

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

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

States a specific verb and resource ('Parses XML sitemaps and sitemap index files into structured URL trees') plus the filter dimension, and explicitly distinguishes itself from extract_page_hyperlinks. An agent can route between the two without opening either schema.

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

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

Gives concrete when-to-use scenarios (discovering domain architectures, mapping crawl frontiers, indexing blog/product catalogues) and names the alternative for the adjacent case, plus the condition that selects it ('raw HTML').

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?

Beyond the annotations (readOnly/idempotent/non-destructive), it discloses operational traits the agent cannot see elsewhere: stateless edge call, 32 KB payload cap, 60 RPM throttle, L402 payment option, demo mode, and HTTP 400 on invalid input. The only defect is that one of these operational details is wrong (see parameter note), so it stops just short of full trust.

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

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

Purpose, verification targets, and the sibling alternative are front-loaded before the operational constraints. Dense but essentially waste-free; the final clause (demo/L402/400) is slightly crammed into one sentence, which is the only reason it is not 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?

Output schema exists, so return values need no explanation, and the description fully covers scope, safety profile, alternatives, and limits. It is near-complete for a 2-parameter read tool, with the chain_id default conflict the one gap that matters to correct invocation.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description actively contradicts the schema: it says 'chain_id' defaults to '1' while the schema says it defaults to '8453' (Base). Since chain_id governs which canonical router spender addresses are used for verification, this error can cause a wrong-chain approval to be judged safe. It also references a '?demo=true' query flag that appears in neither parameter.

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

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

States a specific verb ('Decodes') plus the exact resource ('EIP-712 and Uniswap Permit2 off-chain typed-data payloads') and the outputs of interest (spender identity, uint256.max approvals, expired deadlines). It also contrasts itself with the sibling simulate_evm_transaction_calldata, so an agent can separate the off-chain signing case from raw calldata without opening either schema.

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

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

Explicit when-to-use ('inspecting an off-chain eth_signTypedData_v4 or Permit2 payload before signing') and an explicit when-not with the named alternative and its condition ('raw on-chain hex transaction calldata (0x...) for eth_sendTransaction, use simulate_evm_transaction_calldata instead'). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description goes well beyond them: max 32 KB payload, 60 RPM rate limit, stateless edge call, L402 pricing (20 sats), '?demo=true' bypass, and HTTP 400 on invalid input. These operational traits are exactly what an agent needs before calling an edge endpoint; the only gap is that index/latency behavior is left to the output schema.

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

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

Three tight sentences ordered purpose → when/alternative → operational limits, with zero filler. The final sentence is dense (size, rate, payment, error code all crammed into one clause chain) and could be split for scanability, which keeps it from 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 2-parameter stateless lookup with an output schema and full annotation coverage, the description supplies everything else an agent needs: what it detects, when to call it, the alternative, resource limits, payment model, and failure behavior. Nothing material is missing.

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

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

Schema description coverage is 100%, so both parameters are already documented with enum values and defaults. The description restates that 'address_standard' defaults to 'auto_detect' and surfaces an out-of-schema '?demo=true' flag, but adds no format or validation syntax beyond the schema. Baseline 3 is correct when the schema does the heavy lifting.

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

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

The first sentence states a specific verb and resource (compares a recipient wallet address against recent transaction history) and names the two exact threat classes it detects: vanity prefix/suffix lookalike spoofing and zero-value dusting. It also names the sibling tool it is not (simulate_evm_transaction_calldata), so an agent can route without opening either schema.

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

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

Explicit trigger: 'Use when verifying a recipient EVM or Solana wallet address before sending funds.' It provides an exclusion plus a concrete alternative ('for decoding hex smart contract calldata payloads, use simulate_evm_transaction_calldata instead'), leaving nothing 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?

Beyond the readOnly/idempotent/non-destructive annotations, it discloses statelessness, a 32 KB payload cap, 60 RPM rate limit, demo and L402 (15 sats) access paths, and an HTTP 400 failure mode for invalid input — operationally useful facts an agent cannot infer from structured fields.

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

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

Front-loaded with the purpose and sibling routing before operational details, with no filler. The final sentence is dense with comma-spliced constraints (size, rate, auth, error code), which is efficient but slightly overpacked.

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

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

With an output schema present and annotations carrying the safety profile, the description still covers the limit, auth, and error behaviors an agent needs before calling. Everything required to invoke it correctly is present, apart from the default-value defect noted above.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description actively misleads: it says 'sensitivity' defaults to 'strict_2_repeats' while the schema says it defaults to 'standard_3_repeats' when omitted. That direct conflict on the one behavioral knob can cause an agent to assume a stricter threshold than the server actually applies.

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

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

States a specific verb and resource (analyzes an agent's recent tool-call trace) plus the three concrete failure patterns it detects: identical retry spins, A/B state oscillation, and runaway token burn. It also names the sibling verify_agent_command_safety and the scope that separates them, so an agent can route without opening either schema.

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

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

Explicitly says when to use it ('monitoring autonomous agent execution loops to decide whether to continue or trip a token-burn breaker') and names the alternative for the adjacent case ('for inspecting a single command payload for security threats before execution, use verify_agent_command_safety instead'). Both the include and exclude conditions are stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, but the description adds genuinely non-redundant operational traits: statelessness, a 32 KB payload cap, 60 RPM rate limiting, the 'zero_downtime_strict' default, a demo bypass or L402 payment of 15 sats, and HTTP 400 on invalid input. These are failure modes and cost constraints an agent cannot infer from the annotations.

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

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

Two sentences, purpose front-loaded, then routing advice, then operational constraints. The second sentence is a dense run-on stacking size limit, rate limit, params, payment, and error code, which makes it slightly harder to scan than it could be, 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?

With an output schema present the description need not explain return values, and it already covers inputs, defaults, alternative tool, limits, and error behavior. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns above that by disclosing the default value of 'risk_tolerance' ('zero_downtime_strict'), which the schema does not state, and by naming both required inputs. The enum values themselves are still only explained by 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 precise verb and resource pair ('Compares source and target DDL schemas to identify breaking changes, destructive column drops, and lock-inducing mutations'), and explicitly names the sibling it is not (validate_schema_normalization for normal-form checks). An agent can distinguish this from detect_openapi_breaking_changes and recommend_database_indexes on the description 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?

Gives an explicit trigger ('Use when verifying CI/CD migration scripts before production deployment to prevent downtime') and an explicit exclusion with the correct alternative (validate_schema_normalization for relational normal form). Both when-to-use and when-not-to-use are covered.

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 provides critical behavioral traits beyond the annotations, including resource limitations (32 KB, 60 RPM), operational mode (Stateless read-only edge call), and specific failure modes (HTTP 400 if invalid). This level of detail is essential for an agent operating in a system integrity context.

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

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

The definition is dense and highly technical, which is appropriate for its subject matter. While long, every phrase serves a functional purpose, successfully front-loading the primary goal and scoping constraints within the initial 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?

Given its high complexity and focus on security, the description is nearly exhaustive. It covers input requirements, operational limits, error handling, use cases, and explicit differentiation from related tools, leaving no critical operational 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?

Although the schema coverage is 100%, the description adds significant semantic context. It clarifies the functional role of the inputs (baseline is the trusted past, live is the current measurement) and details advanced invocation parameters like the use of 'demo=true' and specific payment units (L402).

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 purpose is highly specific: it computes structural differences between a pinned baseline and a live response. It clearly states the outcome—catching mid-session description or schema tampering—which is distinct from general auditing functions like `audit_mcp_server_manifest`.

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

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

The usage guidelines are explicitly defined by the operational context. It identifies the primary use case (mid-session verification) and provides a direct alternative sibling tool for a related but different use case (first-time static security audit).

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, closed-world, non-destructive, so the safety profile is covered. The description goes well beyond that with operational details an agent cannot get from structured fields: a 32 KB payload cap, 60 RPM rate limit, L402 payment (25 sats) as an access mode, a '?demo=true' bypass, and HTTP 400 on invalid input — exactly the kind of pre-call context that prevents failed invocations.

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

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

Purpose and the alternative-tool routing come first, followed by the operational constraints, which is the right ordering. It is dense and slightly telegraphic near the end (the '32 KB, 60 RPM ... L402 (25 sats); HTTP 400' clause is crammed), but no sentence is filler.

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

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

An output schema exists, so return values need no explanation. The description covers supported input formats, auto-detection, access constraints, failure mode, and pre-deployment use context — everything an agent needs to invoke it correctly.

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

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

Schema description coverage is 100% with an explicit enum default for contract_format, so the schema does the heavy lifting and the baseline is 3. The description restates 'baseline_schema_json (with enum defaults)' without adding syntax or format guidance, and only the non-schema '?demo=true' query flag is new information.

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

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

States a specific verb and resource set: compares baseline and candidate OpenAPI 3.1 specs, JSON Schemas, or MCP tool manifests to detect breaking changes, with the change classes enumerated (removed fields, new required inputs, narrowed enums, type mutations). The scope is narrow enough that an agent can separate it from generic diffing or schema-compilation siblings without opening a schema.

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

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

Gives an explicit when-to-use framing ('auditing API, JSON Schema, or MCP contract revisions for backward compatibility before deployment') and names one alternative, compile_polyglot_type_schemas, with the condition that selects it. However, the two closest siblings in the roster — detect_mcp_schema_rugpull and detect_breaking_migrations — are never mentioned, leaving real ambiguity for MCP-manifest and migration-adjacent revisions.

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 only declare readOnly/idempotent/non-destructive/openWorld=false; the description goes well beyond them by disclosing statelessness, the 32 KB payload cap, the 60 RPM rate limit, the demo mode and L402 pricing (15 sats), and the HTTP 400 failure mode for invalid input. Those are operational constraints an agent cannot infer from any structured field.

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

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

Purpose and the sibling alternative are front-loaded, then operational facts are packed into a single dense sentence. Nothing is redundant, but the rate-limit/payment/error clause is compressed into a run-on that costs some scanability.

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

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

An output schema exists so return shape need not be explained, and the description still covers the inputs, the default profile, the size and rate ceilings, the payment path, and the failure status. For a read-only three-parameter auditor, an agent has everything needed to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a default the schema omits ('detection_profile' defaults to 'heuristic_dom_overlay') and reiterates the html_content input and demo flag. It does not explain target_domain's publisher-pattern lookup, leaving one property to 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?

States a specific verb and resource — audit DOM hierarchies for soft paywalls, blur overlays, modal gates, plus concealed body text recovery. The title's phrasing is echoed but the description adds concrete detection targets (blur overlays, modal gates) rather than restating the name, and it distinguishes the tool from evaluate_seo_diagnostics by naming that sibling explicitly.

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

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

Gives both when-to-use (diagnosing paywall obstructions, subscriber gating scripts, content access barriers) and when-not-to-use with the exact alternative: 'for assessing general SEO hygiene, use evaluate_seo_diagnostics instead.' That is an explicit routing rule an agent can act on without reading either schema.

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

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

Adds substantial context beyond the already-informative annotations (readOnly/idempotent/non-destructive): 32 KB payload cap, 60 RPM rate limit, demo-mode access, L402 payment cost (10 sats), and HTTP 400 behavior on invalid input. These operational constraints are not derivable from schema or annotations.

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

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

Core purpose is front-loaded in the first sentence, usage/routing in the second, and operational limits in the third. Dense but well-organized; the parenthetical field list and metered detail are tight, though the sentence runs long.

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?

Output schema exists so return values need no explanation, and annotations cover the safety profile. The description nonetheless supplies rate limit, size cap, auth options, and failure mode — everything an agent needs to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description references 'previous_state_json' but attaches '(with enum defaults)', when the enum actually lives on conflict_strategy — a minor imprecision rather than added value. The schema already documents both state params and the conflict_strategy enum.

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

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

States a specific verb and resource set: computes structural diffs between two state snapshots, flags belief contradictions, generates an RFC 7396 patch, and computes a checkpoint hash. Names concrete output fields ('added_keys', 'mutated_keys', 'removed_keys') that let an agent distinguish it from siblings 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?

Explicit when-to-use ('checkpointing agent state or transmitting minimal RFC 7396 state deltas across multi-agent handoffs') plus a named alternative for the adjacent token-budget use case: 'use plan_context_token_budget instead'. Both the positive and negative routing conditions are present.

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 the description goes well beyond them: 32 KB payload cap, 60 RPM rate limit, auth via ?demo=true or L402 (15 sats), and HTTP 400 on invalid input. These are operational constraints an agent cannot get from the structured fields.

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

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

Front-loaded with the core verb and the three transformations, then routing, then operational limits — a sensible order. It is dense in a single block, and the operational/auth tail could be set off more cleanly, but no sentence is wasted.

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

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

Covers purpose, alternative routing, limits, auth, and error signal, and an output schema exists so return values need no explanation. Slight gap: it does not characterize how the three coercion policies differ behaviorally, though the enum descriptions in the schema partially cover that.

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 their own descriptions including the enum and its default, so the schema does the heavy lifting. The description's parenthetical 'raw_output (with enum defaults)' is imprecise since the enum belongs to coercion_policy, adding little and slightly muddling which field is enum-controlled.

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 (validate/coerce/prune a raw LLM output object against a JSON Schema) with the three sub-behaviors named explicitly. It clearly distinguishes itself from the sibling heal_malformed_json by scope: schema/type enforcement versus repairing unparseable JSON 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?

Explicit 'Use when enforcing schema compliance and type safety on structured LLM outputs before passing them to typed APIs', plus an explicit alternative for the adjacent case: 'for healing unparseable raw JSON text... use heal_malformed_json instead.' Both selection condition and exclusion are present.

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?

Goes well beyond the readOnly/idempotent/openWorld annotations: declares statelessness, a 32 KB payload cap, 60 RPM rate limit, demo-mode bypass, L402 payment of 10 sats, and HTTP 400 on invalid input. These are operational facts an agent cannot infer from the annotations or schema.

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

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

Three sentences, front-loaded with purpose, then routing guidance, then operational constraints. Dense but every clause is functional; the parenthetical '(max 32 KB, 60 RPM)' is compressed rather than verbose, though the sentence is somewhat overloaded.

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?

Output schema exists so return shape needn't be described, and annotations cover the safety profile. Description fills the remaining gaps an agent needs: auth mechanics (L402/demo), rate/payload limits, error behavior, and sibling routing. Nothing material is missing.

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

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

Schema coverage is 100% and the sole parameter already documents the enum and the 'half_hour' default, so the schema carries the load. The description reinforces meaning by naming the tiers (fastest, half-hour, hour, economy) in the context of confirmation speed, adding slight framing value over the raw enum 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?

Names a specific verb (Fetches) and resource (Bitcoin mainnet mempool feerate recommendations) with the exact unit (sat/vB) and the four confirmation tiers enumerated. An agent can distinguish it immediately from estimate_solana_priority_fees and plan_bitcoin_utxo_consolidation.

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

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

Explicitly states the use case ('before broadcasting an on-chain BTC transaction') and names the alternative with the condition that selects it ('for calculating exact SegWit/Taproot UTXO batch consolidation vByte weights and dust thresholds, use plan_bitcoin_utxo_consolidation instead'). Both when-to-use and when-not-to-use are covered.

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 non-destructive, so the safety profile is covered. The description still adds real operational context beyond that: statelessness, a 32 KB payload cap, 60 RPM rate limit, demo mode or x402 payment of 10 sats, and an HTTP 400 on invalid input. However, it never says what 'optimal' means or which chain/endpoint is actually called, so it is good rather than exemplary.

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

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

Purpose is front-loaded in the first sentence, usage and exclusion in the second, operational constraints last — a logical order with no filler. The final clause is a run-on cramming statelessness, size cap, rate limit, payment modes and error code into one sentence, which costs some readability.

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

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

With an output schema present, return values need not be described, and the description covers rate limits, size limits, payment/auth paths and failure behavior for a read-only edge call. The one substantive gap is the tx_type default mismatch and the unspecified definition of 'optimal' estimation.

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

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

Schema coverage is 100% with both enums documented, so the baseline would be 3. But the description asserts 'tx_type' defaults to 'simple_transfer', while the schema explicitly says it defaults to 'dex_swap' when omitted — the description actively introduces conflicting parameter semantics rather than merely restating them.

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

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

States a specific verb and resource ('Calculates ... compute-unit microlamport priority fees and Jito bundle tip lamports') plus the objective (target block-inclusion probability). It also explicitly distinguishes itself from the nearest sibling, estimate_bitcoin_mempool_fees, so an agent can route without opening either schema.

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

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

Gives an explicit use condition ('when setting SetComputeUnitPrice and Jito tips before broadcasting a Solana transaction') and an explicit when-not with the named alternative ('for querying Bitcoin L1 sat/vB mempool fee rates, use estimate_bitcoin_mempool_fees'). Nothing about selection is left to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered. The description still adds real operational context: a 32 KB edge call, 60 RPM rate limit, '?demo=true' or L402 payment at 15 sats, and HTTP 400 on invalid input. Return format is left to the output schema, which exists, so the remaining gap is minor.

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

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

Dense but front-loaded: the operation and outputs come first, then the usage routing, then the operational constraints. Every clause carries information, though the parenthetical parameter/query string snippets are cramped and contribute to the misleading parameter claims.

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

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

With an output schema present and rich annotations, the description covers purpose, alternatives, rate limits, payment, and error behavior. The only shortfall is that the treatment_json/demo clauses introduce ambiguity an agent cannot resolve from the schema, which is required-but-required contradiction territory.

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

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

Schema coverage is 100%, so the schema already documents all three parameters and their enum. Worse, the description introduces misleading parameter claims: 'treatment_json defaults to standard' contradicts the schema, where treatment_json is required with no default, and '?demo=true' is a query parameter that does not appear in the input schema at all.

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

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

States a specific verb (computes) and specific statistical resources (Welch's two-sample t-test, two-proportion z-test), and enumerates the concrete outputs (two-tailed p-values, Cohen's d, relative lift, Bayesian P(Treatment > Control)). This is far beyond a restatement of the name and lets an agent know exactly what comes back.

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

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

Explicitly names the trigger scenarios (prompt change, model benchmark, A/B experiment improvement) and explicitly routes the wrong case to a named alternative: 'for evaluating single algebraic formulas or NPV/IRR cashflows, use evaluate_deterministic_math instead'. That is a textbook when/when-not/alternative statement.

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, but the description adds substantive context beyond them: no eval() or dynamic execution, 32 KB payload ceiling, 60 RPM rate limit, demo mode and L402 payment of 10 sats, and HTTP 400 on invalid input. What it omits is return-shape detail, which the output schema supplies anyway.

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?

Capability and routing information is front-loaded and the sentences carry real content (scope, cost, limits, errors). It is dense to the point of being cramped – the rate limit, auth, and error facts are compressed into a single trailing parenthetical rather than structured separately.

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 rich annotations and an output schema, the description still supplies rate limits, payload cap, auth modes, and failure behavior – enough for an agent to call it correctly. The only incompleteness is the conflicting precision default, which leaves the parameter behavior ambiguous between two sources.

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

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

Schema coverage is 100%, so the baseline is 3. The description does add value by noting the 'math_formula' alias and the demo/L402 access paths, but it also states that 'precision_digits' defaults to '2_decimals' while the schema says '8_decimals' – a direct conflict that could lead an agent to miscalibrate rounding.

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

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

States a specific verb and resource family (Shunting-Yard AST arithmetic evaluation) and enumerates the concrete capabilities: algebraic formulas, NPV, Newton-Raphson IRR, Kelly criterion, and descriptive stats. It explicitly separates itself from the sibling evaluate_ab_statistical_significance, so an agent can pick between them without opening either schema.

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

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

The 'Use when…' clause gives the positive trigger conditions and names the alternative tool for the adjacency case (two-sample A/B tests). That is an explicit when/when-not/alternative triple.

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