Hermes Plant

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

The description reveals key behaviors: deterministic scoring, cost mechanics (x402 or free-tier quota), and that it returns one of three concrete decisions rather than executing the action. Annotations already cover readOnly/destructive/idempotent hints, and the description adds cost and determinism context without contradiction.

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

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

The description is a single, information-dense sentence that front-loads the tool's purpose and cost. Every phrase adds value (deterministic, returns next call, cost model), with no fluff or repetition.

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 16 parameters and an output schema, the description conveys the core function and decision outcome well. It does not explicitly mention the required 'command' parameter or how the gate is invoked, but the schema covers that. Slight lack of explicit input guidance keeps it from a 5.

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

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

Schema description coverage is 100% for all 16 parameters, so the schema already documents each parameter. The description adds no additional parameter-level meaning, making the baseline 3 appropriate.

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

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

The description clearly states the tool is a quick safety gate that deterministically scores an action and returns the exact next call (proceed, request DestructGuard evidence, or run full workflow). This specific verb+resource distinguishes it from siblings like action_safety_run and score_destructguard_command.

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

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

The description implies when to use: as a cheap ($0.01) preflight before more expensive or comprehensive workflows, explicitly mentioning the alternative next steps. However, it does not name sibling tools or give explicit 'use this when' / 'use that instead' exclusions, so it falls short of a 5.

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

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

The description goes beyond annotations by specifying side effects: a signed receipt and 30-day status record, and the caveat that triage does not imply human approval. It also discloses conditional ReviewQueue involvement, which is helpful. However, it does not clarify whether the command itself is executed or only preflighted.

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

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

The description is a single, dense sentence that front-loads the purpose and packs in pricing, workflow components, and a caveat. Every phrase adds value; no wasted words.

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?

While the description gives a high-level workflow overview, it leaves out critical specifics: whether the action is executed after a safe decision, and what 'honest decision' entails. The existence of an output schema covers return values, but the description should clarify the preflight nature and relationship to simpler gate tools.

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

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

Schema coverage is 100% with detailed parameter descriptions, so the baseline is 3. Tool description adds no parameter-specific meaning beyond mentioning the payment/quota context. It does not explain how parameters like actorType or paymentSignature affect workflow behavior.

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

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

The description clearly outlines a complete workflow with DestructGuard evidence, conditional ReviewQueue triage, an honest decision, signed receipt, and 30-day status record. It distinguishes itself from siblings like action_safety_quick_gate by the 'complete' scope, though it lacks an explicit verb like 'runs'.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as action_safety_quick_gate or submit_reviewqueue_request. The description mentions conditional triage but does not state when the quick gate should be used instead. This leaves the agent to infer usage from the 'complete' label.

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

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

Annotations already provide read-only/destructive/idempotent hints. The description adds meaningful behavioral context: cost ('$0.05'), payment requirement ('x402-paid'), and record contents ('binding hash, policy verdict, findings, optional settlement outcome'). It does not contradict 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 focused sentences. The first front-loads the tool name, cost, and core action. The second adds a clear usage loop and the benefit. No fluff or repetition.

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

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

Given the tool's complexity (14 params, nested objects) and existing output schema and annotations, the description sufficiently explains the high-level purpose, cost, and usage pattern. It does not detail error cases or parameter construction, but these are covered by the schema and output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add input parameter details beyond the schema; it focuses on the purpose and output. No compensation needed since the schema fully documents parameters.

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

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

The description clearly states the tool's function: 'bind one x402 payment intent or MCP tool call to a canonical HMAC-signed record'. It names specific resources (payment intent, MCP tool call) and the output type (HMAC-signed record). It also distinguishes itself from verification via 'a third party can check at the free verify endpoint'.

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

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

Provides explicit usage context: 'Loop it after every payment or tool call to build a tamper-evident audit trail'. This tells the agent when to invoke it. It also implicitly differentiates from the verify endpoint, but does not explicitly state when not to use other tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable context: it is free, performs server-side recomputation, specifies the hashing algorithm, and reports two booleans (recordHashValid, signatureValid). This exceeds the annotation baseline by explaining the verification mechanics and trust implications, without contradicting any 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 two sentences long and front-loaded with 'Verify a Hermes-signed assurance record for free.' Every clause earns its place: the algorithm, the outputs, and the use case are all covered without any redundant wording.

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 moderate complexity (two nested object parameters, output schema present), the description fully covers the tool's purpose, algorithm, outputs, and usage context. It even notes the free cost and the trust rationale. The output schema likely covers return values, so the description is complete for an agent to decide when and how to invoke it.

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

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

Schema description coverage is 100%, with both 'record' and 'integrity' objects already described in the schema. The description adds that the tool recomputes the hash and signature, but does not provide new semantic detail about the parameters themselves. It stays at the baseline for high schema coverage.

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

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

The description clearly states the tool verifies a Hermes-signed assurance record, detailing the exact process (recomputes canonical hash with hermes-stable-json-v1 + SHA-256 and HMAC signature) and the output fields (recordHashValid / signatureValid). It also distinguishes this from assurance_attest by explicitly naming it as the source of attestations to audit, satisfying the verb+resource+differentiation requirement.

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 'Use it to audit attestations produced by assurance_attest without trusting the agent that produced them,' giving clear when-to-use guidance. It does not name alternative tools or state when not to use it, but the context is strong enough to differentiate from siblings like evidence_verify and assurance_attest.

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 adds important context beyond the annotations: it is x402-paid and deterministic, indicating cost and predictable behavior. Annotations only indicate idempotent and non-destructive, so the payment detail is valuable complementary information.

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 two sentences, front-loaded with the tool's identity and payment requirement, and each clause contributes to understanding the tool's capabilities. No filler or redundancy.

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

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

Given the complexity of the tool with 18 parameters and an output schema, the description covers the essential mode selection and core analytics, while leaving parameter details to the schema. It is sufficient for an agent to choose and invoke correctly, though it could note required parameters for bond mode.

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

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

The schema covers all parameters with descriptions, but the description adds useful grouping for loan mode (principal+annualRate+termMonths) and explains the bond mode's price/yield relationship. This goes beyond the individual parameter descriptions.

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

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

The description clearly identifies the tool as providing bond and loan analytics, with specific functions: solving price-to-yield, duration, convexity, and amortization schedules. It is clear about the two modes, but does not explicitly differentiate from sibling analytics tools like cashflowlens_analyze.

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

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

The description gives concrete guidance on when to use each mode: loan mode requires principal, annualRate, and termMonths, while bond mode handles price/yield relationships. It implies context for usage but does not mention when not to use this tool or name alternative tools.

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

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

Beyond annotations (idempotentHint: true, readOnlyHint: false), the description adds valuable behavioral context: 'x402-paid, $0.20' and 'deterministic.' This informs the agent about cost and consistency, which annotations do not cover. No contradiction with 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 two sentences, front-loaded with the tool name and cost, then lists the computed metrics, and ends with a usage directive. Every sentence delivers value with no repetition of schema or annotations.

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

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

Given the tool's complexity (14 params, nested objects, output schema), the description adequately covers purpose, usage, and key behavioral aspects. The output schema exists, so return values need not be described. It lacks explicit limitations, but the high schema coverage compensates, making it complete enough for agent selection and invocation.

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

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

Schema description coverage is 100%, so the schema fully documents all 14 parameters with descriptions (e.g., 'Cashflows: numbers for periodic, or {amount,date} objects for dated XIRR. Outflows negative.'). The main description adds little parameter-specific detail, but the schema already carries the burden, earning a baseline 3.

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

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

The description clearly states the tool's function: 'deterministic NPV, IRR, XIRR, DCF valuation, MOIC/DPI/TVPI, and payback period from a cashflow series.' It uses specific verbs and identifies the resource (cashflow series), and the listed metrics distinguish it from siblings like bond_analyze or options_price. The phrase 'instead of letting the model estimate' reinforces its unique role.

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 says 'Use for valuation and return analysis instead of letting the model estimate,' providing a clear usage context. While it doesn't name alternative tools or state when not to use it, the instruction is sufficient for an agent to decide when this tool is appropriate.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false. The description adds meaningful context: it's x402-paid ($2.00), deterministic (reinforcing idempotency), and cross-checks results by combining two lenses. This goes beyond the annotations without contradicting 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?

The description is two sentences, front-loading the tool's identity and payment status, then listing concrete capabilities. No fluff or redundancy; it is compact yet information-dense, a model of concise documentation.

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

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

For a complex tool with 12 parameters and nested objects, the description provides a solid overview of what it computes and highlights cross-checking as a value-add. An output schema exists, so return details are not needed. Minor gap: 'sensitivity' is mentioned without explanation, but the schema likely covers it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific meanings beyond what the schema already provides, though it does tie the main input objects (dcf, returns, waterfall) to their output categories. The schema handles parameter semantics adequately.

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

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

The description clearly states the tool performs a full deal underwrite in a single call, listing specific outputs: DCF valuation, fund returns, and LP/GP distribution waterfall. It explicitly distinguishes itself from siblings by noting it combines CashflowLens + WaterfallLens, making its purpose and differentiation unambiguous.

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

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

The description gives clear context that this is the flagship, one-call tool for complete underwriting, and implies alternatives (CashflowLens, WaterfallLens) by saying it combines them. However, it does not explicitly state when not to use it or directly recommend alternatives for narrower 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?

The description adds meaningful behavioral context beyond annotations: it is a pure function with no DNS, costs $0.02 via x402, and mentions how API keys forward payments. It does not contradict the readOnlyHint=false annotation because the payment mechanism is a side effect. It does not fully detail all side effects, but the key ones are disclosed.

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

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

Two crisp sentences. The first front-loads the tool's purpose and cost, and the second adds a key behavioral detail. Every word earns its place.

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

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

With 13 parameters, a rich output schema, and annotations, the description covers the essential behavioral and functional aspects. It mentions cost, determinism, and the pure function nature. It does not mention the batch sibling or alternative usage scenarios, which would improve completeness but is not strictly required given the schema and output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific details beyond the schema, but it does reinforce the purpose of the email parameter via the overall use case. No additional semantic value is provided.

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

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

The description clearly identifies the tool as a deterministic email/contact quality scorer with specific outputs (validity, deliverability score, disposable/role/free classification, typo suggestion). It distinguishes itself from the batch sibling in name but does not explicitly contrast with it, which is the only gap.

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

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

No explicit guidance on when to use this tool versus alternatives like emailguard_validate_batch. It implies use for single-email validation and notes cost and payment options, but does not state exclusions or compare to sibling tools, leaving the agent without clear selection criteria.

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

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

Beyond the annotations (readOnlyHint false, idempotentHint true, destructiveHint false), the description adds valuable behavioral details: quota consumption per record, deterministic verdicts, preservation of input order, and the partial-failure behavior where the batch stops at a 402 and marks remaining records as skipped. This is substantial and consistent with 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?

The description is two sentences, front-loaded with the core function and followed by key operational details. Every phrase earns its place—no filler or repetition, making it highly efficient.

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

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

The tool has a rich output schema (not shown but indicated), annotations, and a thorough input schema. The description covers the essential behavioral aspects (quota, ordering, failure handling, deterministic results) and does not need to explain return values given the output schema. It is complete for an agent to use the tool correctly.

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

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

The input schema provides 100% coverage of all 10 parameters with detailed descriptions, including apiKey, records, and payment-related fields. The description adds minimal parameter-specific information beyond what the schema already states, such as highlighting the 'free apiKey' and quota link, but this is mostly redundant.

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 'Validate up to 20 emails in one tool call' and lists specific outputs (validity, deliverability score, disposable/role/free classification, typo suggestion, canonical normalization). This clearly distinguishes it from the sibling emailguard_validate, which likely handles a single email.

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

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

The description provides clear context for when to use this tool (batch validation of up to 20 emails) and mentions prerequisites like the free apiKey and quota. It does not explicitly state when not to use it or name the alternative, but the title and 'whole contact list' strongly imply batch use, making the context sufficient.

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 adds behavioral information beyond annotations: it discloses the $0.05 x402-paid cost and the exact return statuses ('verified / needs_review / rejected / insufficient_evidence'). It also names specific integrity checks (hashes, freshness, etc.). No annotation contradiction exists; readOnlyHint=false aligns with the paid nature.

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

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

The description is a single dense sentence that packs cost, purpose, artifact types, checks, and return statuses without wasted words. It is front-loaded with the tool name and cost. Slightly dense due to hyphenated lists, but every clause earns its place.

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

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

Given the tool's complexity (12 params, nested objects) and the presence of an output schema, the description covers the essential context: when to use, what it checks, cost, and return types. It does not delve into every verification rule, but the output schema likely covers that, making the description sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds high-level context about what artifacts are relevant, but does not elaborate on individual parameter formats or constraints, which are already fully documented in the schema.

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

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

The description clearly states the verb 'verify' and the resource 'agent-commerce evidence bundle', precisely defining what the tool does. It distinguishes itself from siblings like assurance_verify by focusing on x402-paid result evidence, artifact types, and specific checks (endpoint/price binding, freshness, hashes, synthetic-proof leakage).

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

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

The phrase 'before trusting a paid result' explicitly identifies the target usage context. While it does not name alternative tools or explicit exclusions, the context is sufficiently clear for an agent to decide when to invoke this tool versus others.

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 and idempotentHint, so the safety profile is covered. The description adds useful behavioral context by specifying what the check reveals (quota, reset date, upgrade path) and the key format. It does not contradict 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 two sentences: the first clearly states the tool's purpose, and the second provides the parameter format and alternative action if no key exists. It is front-loaded, concise, and every word serves a purpose.

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

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

For a simple 1-parameter read-only tool with an output schema present, the description covers the input, the key format, and how to obtain a key if missing. No critical context 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%, as the single parameter apiKey is already described as 'Your free-tier key (hp_free_...)'. The description repeats this instruction ('Pass your hp_free_ key as apiKey') without adding new semantic details, so it adds minimal value beyond the schema.

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

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

The description clearly states the tool's function with a specific verb ('Check') and resource ('free API key'), and lists the exact outputs ('remaining monthly quota, reset date, upgrade path'). It distinguishes itself from sibling tools, which focus on analysis, validation, or purchasing, none of which relate to key status.

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

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

The description provides explicit usage context: pass your hp_free_ key as apiKey, and if you don't have a key, it directs you to a signup endpoint. It does not mention when not to use it or alternatives among siblings, but the guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's safety profile is covered. The description adds that the output is legal policy URLs, which is useful, but it doesn't elaborate on other behavioral aspects like authentication or rate limits. With annotations carrying the safety burden, this is adequate.

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

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

The description is a single, focused sentence that states exactly what the tool does. No wasted words; it's appropriately brief for a zero-parameter read operation.

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

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

With no parameters, a read-only annotation, and an output schema present, the description provides sufficient context. The 'required before checkout' indication supplies the key usage scenario. The description is complete for this simple tool.

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

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

The tool has zero parameters, so there is no burden on the description to explain parameter semantics. Baseline of 4 is appropriate given no parameters exist.

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

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

The description uses a specific verb ('Return') and defines the resource ('legal policy URLs') and context ('required before checkout'). This clearly distinguishes it from sibling tools like start_checkout or payment_policy_decide.

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

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

The phrase 'required before checkout' implies when to use this tool, providing clear contextual timing. However, it does not explicitly mention alternatives or when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description need not repeat these. However, the description adds no additional behavioral context such as error handling, authorization, or not-found behavior, providing no value beyond the annotations.

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

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

The description is a single, focused sentence with no redundant wording. It is appropriately concise for a simple retrieval operation and front-loads the key action.

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

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

Given the tool's simplicity (one parameter, read-only, idempotent, output schema present), the description is complete enough. It fully conveys the purpose and mechanism without needing to elaborate on return values or edge cases, as the schema and annotations cover the rest.

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

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

The input schema provides 100% coverage for the slug parameter with its description 'Product slug from the catalog'. The description's mention of 'by slug' merely restates the parameter and does not add semantic meaning beyond the schema.

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

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

The description 'Get a single product by slug' clearly specifies the action (get), resource (product), and identifier (slug), effectively distinguishing it from sibling tools like list_products. It is concise and unambiguous.

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

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

The description implies the tool is for retrieving one product when its slug is known, but it does not explicitly state when to use it over alternatives or exclude other cases. No when-to-use or alternative guidance is provided beyond the basic 'by slug' context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is known to be a safe, non-mutating read. The description adds the word 'live,' implying the manifest is fetched in real time rather than cached, and lists the returned content. However, it does not disclose potential failure modes, rate limits, or whether any policy checks might block the result.

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

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

The description is a single, front-loaded sentence that communicates the essential purpose without any filler. Every word contributes to understanding what the tool returns.

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 zero-parameter input schema, the existing output schema, and the strong annotations (readOnly, idempotent), the description is sufficient. It names the three key elements of the manifest and implies a live fetch, which is enough 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?

The tool has zero parameters, so the schema leaves nothing to clarify. Per the scoring baseline, a zero-parameter tool receives a 4, and the description does not need to add parameter-level meaning.

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

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

The description uses the specific verb 'Return' and identifies the exact resource, the x402 manifest, along with its key contents: paid endpoint prices, Bazaar metadata, and buyer policy checks. This clarity distinguishes it from sibling tools like get_checkout_policies or purchase_with_x402, which serve different purposes.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, such as get_checkout_policies, list_products, or payment_policy_decide. There is no mention of prerequisites, ordering, or scenarios where this tool should be preferred.

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

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

Annotations already declare the operation read-only and idempotent, so the safety profile is covered. The description adds valuable context by specifying that only active products from the Hermes Plant catalog are returned, giving a concrete behavioral filter beyond the annotations. No return-format detail is needed since an output schema exists.

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

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

The description is a single, front-loaded sentence that is concise and information-dense. It contains no filler or redundant phrasing, earning a perfect score.

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

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

Given the tool's simplicity (no parameters, output schema present, read-only annotations), the description is fully sufficient. It identifies the exact scope (active products in the Hermes Plant catalog) and all other contextual information is covered by annotations and the output schema.

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

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

The tool takes zero parameters, so the description carries no parameter burden. The baseline of 4 applies because there are no parameters to describe, and the schema has no properties, so there is no gap to compensate for.

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

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

The description clearly states the action (list), the resource (products), and a specific qualifier (active products from the Hermes Plant catalog). This distinguishes it from sibling tools like get_product, which retrieves a single product.

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

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

The description provides clear context by indicating that the tool lists active products, implying it is used when a catalog listing is needed. However, it does not explicitly mention alternatives such as get_product for single-item lookups, so it lacks explicit exclusions or when-not-to-use guidance.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true), the description adds key behavioral facts: it is x402-paid ($0.05) and intended as a pre-install safety check. It does not contradict annotations, and while it doesn't detail side effects like network calls, the payment disclosure is valuable. The tool's scoring nature is consistent with idempotentHint=true.

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

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

A single, densely informative sentence: it leads with the tool's name and cost, states its action ('score'), the object ('MCP server manifest'), the condition ('before install'), the risk dimensions, and the output ('per-tool findings and fixes'). No filler or repetition.

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 13 parameters, an output schema, and a clear one-sentence purpose, the description covers the essential context. It mentions the output briefly, and the fact that it's paid is included. Slight room for improvement in giving a concrete example of the risk score, but overall it is complete for selecting and correctly invoking the tool.

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

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

Schema coverage is 100% with detailed parameter descriptions, so the baseline is 3. The description adds meaning by relating the input to MCP server manifests and risk categories (e.g., 'destructive tools' hints at the tools[].network and permissions fields), but it doesn't explicitly explain how to populate parameters beyond what the schema already offers.

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

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

The description clearly states the tool's specific purpose: 'score an MCP server manifest for security risk before install'. It enumerates what it checks (destructive tools, over-broad scopes, weak auth, egress) and the deliverable ('per-tool findings and fixes'), which distinguishes it from sibling tools like action_safety_quick_gate or walletguard_score that target different aspects of security.

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

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

The description provides a clear context: use before installing an MCP server. It implies this is a pre-install assessment, separating it from tools that analyze runtime actions or payments. While it does not explicitly name alternatives, the specificity of 'MCP server manifest' gives strong guidance on when to invoke it.

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

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

The description discloses that the tool is deterministic and paid, which goes beyond the annotations (idempotentHint=true, readOnlyHint=false). It adds cost context and determinism, which are useful for the agent. There is no contradiction with 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?

The description is a single, front-loaded sentence that includes the tool name, payment info, and core outputs. Every clause adds value with no fluff or redundancy.

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

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

For a mathematically complex tool, the description covers the pricing model, option type, and outputs (Greeks, dividend yield, intrinsic/time value, moneyness). The presence of an output schema means return values need not be described. Minor gaps like default values for risk-free rate are left to the schema, but the description is sufficiently 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?

The input schema has 100% coverage for all 16 parameters, so the baseline is 3. The description mentions dividend yield and computed outputs (intrinsic/time value, moneyness), which adds some context beyond the schema, but it does not provide additional syntax or detailed parameter guidance. It slightly enhances understanding of the dividendYield parameter's role.

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

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

The description clearly states the tool computes Black-Scholes price and full Greeks (delta, gamma, vega, theta, rho) for European calls/puts. It uses a specific verb ('price') and resource ('OptionLens'), and the scope (European options) distinguishes it from sibling tools like bond_analyze or cashflowlens_analyze.

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

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

The description implies the tool is for European options pricing and mentions it is paid ($0.30), but it does not explicitly state when to use this tool over alternatives or describe exclusion criteria. No sibling alternatives are referenced, so usage guidance is only implied.

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

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

The description adds behavioral context beyond annotations by stating the tool is deterministic, produces 'evidence-backed findings', and costs $0.05, while clarifying it operates before payment signing. It also mentions specific safety checks (replay readiness, PII leakage). No contradiction with 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 two sentences, front-loads the tool's name and cost, and every clause delivers substantive information without repetition. The dense list of checks is efficiently packed and adds value.

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

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

Given 21 parameters, nested objects, and an output schema, the description effectively covers purpose, workflow, and complementary tools while relying on the output schema for return values. It could mention prerequisites (like apiKey) explicitly, but overall it provides sufficient context for an agent to decide when and how to invoke the tool.

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

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

Although schema covers 100% of parameters, the description enriches semantics by mapping policy checks (resource binding, amount vs expected price, network, payTo, facilitator, replay readiness, PII leakage, buyer spend limits) to relevant input parameters. This helps agents determine which parameters are essential for a given preflight.

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?

Description explicitly states the tool performs 'deterministic allow / deny / needs_review' for an 'x402 payment' before signing, clearly defining its role as a preflight decision tool. It distinguishes itself from siblings by naming the pairing with assurance_attest and specifying the exact checks performed.

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?

'Loop it over every payment' provides direct guidance on when to use the tool, and 'pair with assurance_attest for a signed record' indicates a complementary workflow. However, it does not explicitly list alternatives or when not to use this tool, so it falls short of a 5.

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

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

The description adds behavioral context beyond annotations by disclosing the x402 payment requirement and deterministic nature. It also lists the metrics returned. Annotations (readOnlyHint=false, idempotentHint=true) are not contradicted; the description aligns with idempotency via 'deterministic.' No negative side effects are described, but the payment aspect is a meaningful behavioral trait.

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

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

The description is a single, information-dense sentence that names the tool, pricing, core behavior, and key metrics. It is front-loaded and every clause adds value without redundancy.

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

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

The description covers the main output and input expectation scorely well, but it does not mention optional parameters or the need for an apiKey unless a user has a free-tier key. The output schema exists, so return values are not required in the description. It is complete enough for a typical scoring tool, though slightly sparse on prerequisites.

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 description mentions 'from holdings' which loosely maps to the required holdings parameter. However, it does not add detail about the other 11 parameters such as riskFreeRate, periodReturns, or apiKey. The baseline of 3 applies because the schema already documents all parameters clearly.

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

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

The description clearly states the tool's function: 'deterministic portfolio risk scoring from holdings' and enumerates specific metrics (volatility, Sharpe, max drawdown, concentration, diversification). This is a specific verb+resource that distinguishes it from sibling tools like walletguard_score or mcp_risk_score.

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

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

The description implies usage context ('from holdings') and suggests it is for portfolio risk assessment, but it does not explicitly state when to use this tool over alternatives or provide exclusions. No alternative tool names are mentioned, so guidance is only implicit.

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 discloses the 402 challenge/fulfillment behavior and the retry with PAYMENT-SIGNATURE, which goes beyond what annotations (readOnly=false, openWorld=true) state. It adds context about the protocol flow but does not cover permissions or rate limits. No contradiction with 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?

A single, information-dense sentence that opens with the core purpose and packs the necessary workflow into a compact instruction. No fluff or redundancy.

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

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

Given an output schema exists and the description covers the return type and the full purchase-retry workflow, it is quite complete. Minor omissions include error cases and rate-limit details, but the essential behavior is well conveyed.

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 covers 100% of parameters, so baseline is 3. The description adds procedural context (verify manifest fields, sign and retry), which clarifies the purpose of paymentSignature and places parameters in the x402 flow. This elevates it above the baseline.

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

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

The description clearly states the action ('Purchase'), the object ('one-time product'), and the method ('via x402'), distinguishing it from sibling tools like get_x402_manifest and start_checkout. The parenthetical about return types further specifies the tool's unique role.

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

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

Provides explicit sequencing ('Call get_x402_manifest first... then sign and retry'), which is strong usage guidance. However, it does not explicitly state when not to use this tool or mention alternatives like start_checkout, so it falls short of a 5.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false, but the description goes beyond by disclosing that this is a paid x402 service, that payment is required, and that it functions as a paid retry mechanism. This adds material behavioral context about cost and workflow, though it doesn't detail all potential side effects.

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 two sentences, front-loaded with the core purpose, and provides the essential workflow without redundancy. Every sentence 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?

Given the high complexity (15 parameters), the description covers the key workflow and payment expectation, while the rich input schema and output schema fill in the details. However, it could have been more complete by briefly noting which parameters are essential (e.g., command, paymentSignature) beyond the required 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 description coverage is 100%, with every parameter (including apiKey, xPayment, paymentSignature) having a detailed description. The tool description itself does not add parameter-level semantics, so a baseline of 3 is appropriate.

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

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

The description clearly identifies the tool's purpose: 'Score a command/action with the x402-paid DestructGuard service.' It uses a specific verb ('score') and resource ('command/action'), and the mention of 'DestructGuard' and 'x402-paid' distinguishes it from sibling safety/risk tools like action_safety_quick_gate or mcp_risk_score.

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

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

The description provides explicit usage context: 'Call get_x402_manifest first, verify the DestructGuard price and buyer policy, then retry the 402 challenge with an x402 payment signature.' This gives a clear prerequisite and workflow, but it does not mention when to avoid this tool or contrast it with alternatives, which would merit a 5.

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

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

Annotations already convey that this is non-read-only, non-idempotent, and has external side effects (openWorldHint true). The description adds context that it is a Stripe checkout session, implying a payment flow, but does not disclose additional behavioral details like session expiration or redirect behavior. No contradiction with 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 a single concise sentence that immediately states the tool's purpose. There is no redundant or unnecessary wording.

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?

This is a simple one-parameter tool with full schema coverage, an output schema, and safety-relevant annotations. The description, combined with the schema and annotations, provides sufficient context for an agent to select and invoke the tool correctly.

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

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

The schema description for the single parameter 'slug' is fully provided ('Product slug to purchase'). The description merely restates 'for a product slug' without adding additional meaning beyond the schema.

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

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

The description clearly identifies the action (starting a checkout session), the resource (Stripe checkout session), and the required input (product slug). This differentiates it from sibling tools like get_checkout_policies or list_products.

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

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

The description implies when to use the tool (when starting a checkout for a product) but does not explicitly mention alternatives or exclusions, such as when to prefer purchase_with_x402 or get_checkout_policies.

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=false, destructiveHint=false, and idempotentHint=true. The description adds meaningful behavioral context by noting the service is x402-paid and requires a payment signature for retry, plus the prerequisite verification of price and buyer policy. It does not contradict 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?

The description is two sentences, front-loaded with the primary action, and every sentence adds value: the first defines the tool, the second gives the required workflow. No wasted words.

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 15 parameters and an output schema, the description is appropriately minimal but covers the essential workflow (manifest, price verification, retry with payment). It provides enough context for an agent to select and invoke the tool correctly, though it could slightly expand on alternative payment methods (e.g., apiKey) but those are already in the schema.

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

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

Input schema has 100% parameter description coverage, so the schema already documents all parameters. The description itself does not add extra parameter semantics beyond the schema, matching the baseline of 3 when schema coverage is high.

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

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

The description clearly states the tool's purpose: submit a command/action to the x402-paid ReviewQueue agent service. The verb 'submit' plus the specific resource 'ReviewQueue agent service' precisely defines the action and distinguishes it from sibling tools like get_x402_manifest or purchase_with_x402.

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

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

The description provides explicit usage context: 'Call get_x402_manifest first, verify the ReviewQueue price and buyer policy, then retry the 402 challenge.' This clearly indicates when to use the tool and the required sequence, though it does not explicitly mention when not to use it or name alternatives.

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

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

Beyond annotations (idempotent, not destructive), the description discloses a $0.10 x402 payment requirement, deterministic behavior, and evidence-backed findings. This adds meaningful behavioral context not captured in annotations, though it doesn't detail payment 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?

The description is very concise, two sentences, with key info first (name, cost, function). No wasted words, and it front-loads the essential differentiators.

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 exists and the schema documents all parameters, the description covers the essential input categories and return types. It doesn't elaborate on payment mechanics, but that's covered by parameter docs and the x402 mention, making it sufficient for a complex tool.

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

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

The schema covers all 15 parameters with descriptions, so the description's mention of 'sanctions, exposures, labels, fund sources' adds minimal extra meaning. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly identifies the tool as a deterministic wallet AML/compliance risk scorer returning a 0-100 score, level, and evidence-backed findings. It distinguishes from sibling tools like portfolioguard_score and mcp_risk_score by explicitly stating the wallet AML focus and caller-provided context inputs.

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

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

The description implies usage when wallet AML risk scoring is needed, noting inputs like sanctions, exposures, labels, and fund sources. However, it does not explicitly state when to use this over alternatives or mention any exclusions, so the guidance remains implicit.

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 idempotentHint=true and destructiveHint=false. The description adds 'deterministic' (reinforcing idempotency) and discloses cost ('x402-paid, $0.30') and the output metrics computed. This goes beyond annotations without contradicting 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?

The description is a single, information-dense sentence that includes the product name, cost, deterministic nature, calculation components, and outputs. Every clause adds value with no wasted words, and the most important identifiers are front-loaded.

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

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

Given the tool's complexity (17 parameters, 2 required) and the existence of an output schema, the description is sufficiently complete. It captures purpose, calculation logic, cost, and key outputs, while the schema handles parameter details. It adequately prepares an agent to select and invoke the tool correctly.

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

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

The input schema has 100% description coverage for all 17 parameters, so the baseline is 3. The description does not explain individual parameters but outlines the calculation stages that correspond to parameters (e.g., contributedCapital, preferredReturnAmount). It adds no parameter-specific semantics beyond the schema.

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

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

The description clearly states a specific verb ('distribution waterfall') and resource (WaterfallLens), and details the exact calculation stages (return of capital, preferred, GP catch-up, carried-interest split). It also lists key outputs (LP MOIC, effective carry %), making it easily distinguishable from sibling tools like cashflowlens_analyze or dealanalyzer_analyze.

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

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

The description implies usage for LP/GP distribution waterfall calculations but does not explicitly state when to use it versus alternatives. It provides no exclusions or recommendations for choosing this tool over other financial analysis tools, leaving usage context implicit.

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