DPX — Institutional Cross-Border Settlement

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

The description discloses that DPX calls the external GLEIF API to verify active LEI status and grants VERIFIED instantly, and that all tiers are instant with no manual review. This goes beyond the annotations (readOnlyHint false, etc.) by explaining the external dependency and the lack of document review. It also specifies caps per tier. 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 dense paragraph without bullet points or headings. It includes extensive legal citations and repeated statements about no documents and instant verification. While every sentence provides information, the structure hampers quick scanning. It could be condensed and organized with tier breakdown.

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 registration tool with 8 parameters and nested objects, the description covers the tiering logic, compliance caps, and external verification. It does not describe error handling or output details, but the presence of an output schema mitigates that. Overall, it is comprehensive enough for an agent to invoke 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 100% schema coverage, baseline is 3. The description adds meaning by mapping parameters to tiers: name→ANONYMOUS, ownerEntity/ownerEmail→REGISTERED, ownerLei→VERIFIED, and mandate restricted to REGISTERED/VERIFIED with clamping to tier caps. This contextual mapping is not fully present 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 identifies the tool as agent registration with a three-tier compliance model (ANONYMOUS, REGISTERED, VERIFIED) and specific caps per tier. The verb 'register' and resource 'KYA agent' are explicit, and the description distinguishes it from potential verification tools by detailing the registration process.

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

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

Usage is implied: to create an agent with desired compliance tier and caps, use this tool. However, there is no explicit comparison with sibling tools like agent.kya_verify or agent.mandate_create, and no exclusion criteria (e.g., 'use this only for new agents'). The description does state conditions for each tier, which helps decide when to use.

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 readOnly, but the description adds behavioral details: 1-hour expiry, signed credential, header attachment, and what the credential enables. 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?

Three dense sentences with no filler. Each sentence earns its place: purpose, usage/headers, and expiry/refresh instruction.

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 output schema exists, so return values are covered. The description provides sufficient context for successful invocation: prerequisites (registered agent ID), expiry behavior, and integration with /settle, making it complete for its complexity.

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

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

Schema coverage is 100% and the single parameter agentId is already described. The description adds value by specifying the format (agt_... from agent.kya_register) and how the value is used in headers.

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 ('Verify') and resource ('registered DPX agent'), and clarifies the outcome (signed 1-hour credential). It distinguishes from sibling kya_register by focusing on verification rather than registration.

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 states when to use (before DPX /settle requests) and instructs to call again before credential expiry. It does not explicitly mention alternatives or exclusions, but the context 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?

The description discloses key behavioral traits not in annotations: tier-based cap clamping ($25K for REGISTERED), unlimited caps for VERIFIED, AP2 formatting, and the create/update (upsert) nature. The annotations (readOnlyHint=false, idempotentHint=false) align with this, and the description adds meaningful operational 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?

Four sentences front-loaded with purpose, followed by constraints then eligibility rules. Every sentence adds value—no filler, no repetition of schema details verbatim.

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, the description covers prerequisites, behavioral limits, and interoperability. It could mention how updates merge vs replace, but that's not critical given the output schema and overall richness.

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 adds semantic context by listing constraint types (max notional, daily cap, whitelist) in natural language, reinforcing the schema. It also clarifies whitelist accepts LEIs or wallets, matching the schema but making the purpose clearer.

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-resource pair 'Create or update an AP2-compatible spend mandate' and clearly targets REGISTERED or VERIFIED DPX agents. It enumerates the constraint fields, distinguishing it from sibling agent tools like agent.kya_register and agent.kya_verify.

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 anonymous agents cannot hold mandates and tells users to register first, giving a clear prerequisite and exclusion. It doesn't name alternative tools by name, but the registration reference and sibling names are sufficient context. It also differentiates between registered and verified caps, guiding when each applies.

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 openWorldHint=true. The description adds 'live' and 'across all data sources', giving useful behavioral context. However, it doesn't disclose limitations like data freshness or potential delays, which would be valuable for a monitoring 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 two sentences: the first lists outputs, the second lists use cases. Every word earns its place, and key information is 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?

Since the tool has no parameters and an output schema exists, the description only needs to convey purpose and typical use. It covers the main content areas (stability, ESG, fees, oracle health, settlement) and is adequate for an agent to decide whether to invoke it.

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

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

The tool accepts zero parameters, so there is no ambiguity. The description does not need to explain parameter semantics, warranting the baseline score of 4 for this dimension.

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 retrieves live DPX performance analytics and enumerates the specific metrics returned (stability score, ESG composites, fee breakdown, oracle health, settlement readiness). This distinguishes it from more focused sibling tools like oracle.status or esg.score, matching the 'overview' name.

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 states intended use cases: 'Use for dashboards, reporting, and AI-driven monitoring of protocol health.' This provides clear context for when to use the tool, though it does not mention when not to use it or list 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?

With annotations all false, the description carries the burden and discloses key behavioral traits: concurrent execution, failure isolation ('one failure does not block others'), and return summary with per-item results. This adds substantial value beyond the annotations, though it does not cover authentication or rate limits.

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

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

Every sentence serves a purpose: batch operation, concurrency/failure behavior, return format, and limit. No filler or redundancy, and the most important information is 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?

The description covers purpose, concurrency, failure behavior, return summary, and max limit. Since an output schema exists, return details are not repeated. It is mostly complete, though it could optionally note prerequisites or error handling specifics, but these are not essential.

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 already covers the single parameter 'settlements' with a description referencing the settle tool schema, so the baseline is 3. The description adds no additional parameter-specific semantics beyond noting the max batch size, which is already 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 states a specific verb and resource: 'Submit multiple settlements in a single call.' It clearly distinguishes from siblings by emphasizing the batch nature, and the title/maximum batch size further clarifies scope.

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

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

The description implies usage for multiple settlements (e.g., 'Submit multiple settlements in a single call') and sets a maximum of 50, but it does not explicitly name alternatives or state when not to use it. The context is clear but lacks explicit exclusions or comparisons.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context beyond these: it confirms zero execution side effects ('No settlement is executed') and notes the tool is 'Free.' It also describes the nature of the output (an optimal settlement plan with corridor selection, stablecoin choice, and fee), which clarifies the read-only analysis 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 concise (four short sentences) and front-loaded with the core purpose. Every sentence adds value: purpose, input/output, side-effect disclaimer, and usage ordering. The example is embedded naturally, and no words are 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?

Given the tool's moderate complexity (2 params, no output schema) and strong annotations, the description covers all essential aspects: what it does, what input it expects, what output it returns, that it is non-executing, and how it relates to the settlement workflow. The output components (corridors to settle/hold, stablecoin choice, estimated fee) adequately substitute for a missing 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 coverage is 100%, so both parameters are documented. The description enriches the semantics with a concrete example of the positions array ('USD-BRL: $2.3M, USD-EUR: €450K') and clarifies that inputs are net positions per corridor, adding meaning beyond the schema's generic item description.

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: 'Plan treasury settlement for a crypto card program.' It specifies the resource (treasury settlement), the action (plan), and differentiates from execution tools by noting 'No settlement is executed' and explicitly recommending 'Call this before card.settle.' This is a specific verb+resource+scope that distinguishes it from siblings.

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

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

The description provides explicit usage guidance: 'Call this before card.settle to review the plan.' This names the alternative execution tool and establishes a temporal order. It also clarifies what the tool does not do ('No settlement is executed'), giving a clear when/when-not boundary.

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?

With all annotations set to false, the description carries the burden of disclosing behavioral traits. It clearly states that it 'executes all settlements via DPX batch' and mentions compliance gating, oracle pricing, and stablecoin routing, indicating a state-changing on-chain operation. It also warns about the required recipientAddress and suggests sandbox for testing, implying production use has real consequences. It does not discuss failure modes or idempotency, but covers the main operational 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 five short sentences, each delivering distinct information: the core action, the execution method, the required recipientAddress, testing guidance, and the return format. There is no fluff or redundancy, and it front-loads the purpose immediately. Every sentence earns its place, making it compact yet informative.

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

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

For a settlement tool with two parameters, high schema coverage, and no output schema, the description covers the essential aspects: what it does, how it works (DPX batch), compliance/oracle/stablecoin context, the required recipientAddress, sandbox testing, and the return value. It does not mention error handling, idempotency, or prerequisites beyond recipientAddress, but given the complexity and the lack of annotations, it is sufficiently complete to guide an agent.

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 already describes both parameters with 100% coverage, including an example for positions and an explanation for sandbox. The description adds value by noting that the positions array is 'the same as card.positions,' providing a useful cross-reference, and reiterating the recipientAddress requirement. It also reinforces sandbox semantics with 'Use sandbox:true for testing.' This goes beyond simply repeating schema fields.

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

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

The description opens with 'Execute treasury settlement for a crypto card program,' a specific verb+resource pairing that clearly states the tool's function. It further distinguishes itself from card.positions by noting it 'executes all settlements via DPX batch' rather than merely listing positions. This makes the purpose unambiguous and differentiates it from sibling tools.

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

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

The description provides clear context: it is for executing treasury settlements for a crypto card program, and explicitly recommends 'Use sandbox:true for testing.' It also references card.positions for the array format, implying this is the execution counterpart. However, it does not explicitly state when to avoid using it or mention alternatives like settlement.execute or batch_settle, so it lacks explicit exclusionary 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 the annotations (readOnlyHint, openWorldHint, idempotentHint, non-destructive), the description adds valuable behavioral context: it enumerates the output fields (match confidence, position/role, nationality, related entities, risk level) and interprets the risk levels with a compliance action (EDD). This is more than a mere restatement of 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 three sentences, each serving a distinct purpose: what it does, what it returns, and what to do with the results. It is front-loaded with the primary action and does not waste words, though it could be tightened slightly without losing 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 the tool's moderate complexity (2 params, output schema present), the description covers the core aspects: subject, dataset, return values, and post-settlement implications. It does not mention edge cases like name-matching limitations, but the openWorldHint annotation already signals the dataset's non-exhaustive nature, so the description is 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 coverage is 100%, with both 'q' and 'country' having descriptive text. The description adds only 'Optionally filter by country,' which restates the schema. No new format, syntax, or edge-case details are provided, so a baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Screen an individual by name') against a named resource ('OpenSanctions PEP dataset'), and goes on to define PEPs and list the returned fields. However, it does not explicitly distinguish itself from sibling tools like ramp.compliance_screen, so it stops short of a 5.

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

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

The description implies a compliance use case by stating that HIGH or MEDIUM matches require EDD before settlement, giving context about when to act on results. It does not explicitly mention when to use this tool instead of alternatives (e.g., compliance.ubo_chain), nor does it state when not to use it.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral context by detailing the exact return format (framework, jurisdiction, requirement summary, effective date, impact level, article reference) and the DPX alignment section, going beyond what annotations provide.

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 four sentences, each earning its place: the first states the core function, the second lists output fields, the third adds the DPX alignment section, and the fourth gives usage guidance. No redundancy or 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?

With no parameters, clear annotations, and an output schema, the description covers all necessary information: purpose, output details, and recommended use cases. An agent can correctly select and invoke this tool based solely on the description.

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 baseline is 4. The description adds no parameter-specific information, but none is needed since there is nothing to configure.

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 fully states the tool's purpose with a specific verb and resource: 'Returns a structured calendar of upcoming and in-effect compliance obligations' across a clearly enumerated set of regulations. It also lists the output fields and an additional DPX alignment section, making it easy to distinguish from sibling compliance tools like pep_screen or ubo_chain.

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 tells the agent when to use the tool: 'Use this before settlement workflow design, compliance gap analysis, or regulatory reporting.' This provides clear context, though it does not mention when not to use it or alternative tools, so it stops short of a full 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?

Even though annotations already declare readOnly, idempotent, and non-destructive, the description adds substantial behavioral context: data sources (GLEIF, OpenSanctions list), traversal behavior, per-node sanctions status, LEI lapse flags, verdict categories, and FATF R.16 attestation. This goes well beyond 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 three sentences, front-loaded with the core action, then output details, then use cases. Each sentence carries distinct information and there is no filler or redundancy. It is dense but appropriately sized for a tool of this complexity.

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

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

With an output schema present, the description does not need to explain return structures. It covers purpose, method, data sources, verdict types, and regulatory use cases. Annotations cover safety profile. There are no significant gaps for an agent to select and invoke this 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 already provides full descriptions for both params (lei and deep) with 100% coverage. The description restates depth capability ('up to 3 levels') but adds no new parameter-specific meaning beyond what the schema offers, so 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 uses a specific verb 'Trace' with a clear resource ('beneficial ownership chain'), specifies depth ('up to 3 levels'), and names the downstream action ('screen every node against OpenSanctions'). It also lists concrete return values, making its purpose unmistakable and distinct from sibling tools like compliance.pep_screen.

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 names use cases ('correspondent banking due diligence', 'FATF R.12/13 UBO identification', 'MiCA Article 72 counterparty risk management'), giving clear context for when to use. It does not explicitly state when not to use it or name alternatives, 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 and idempotentHint. The description adds behavioral context: it returns the best free model, strengths, speed tier, and alternatives, and notes that it is free. No contradictions 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 three concise sentences covering purpose, usage, and a key note ('Free'). It is front-loaded and every sentence 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?

The description fully explains what the tool returns and when to use it. No output schema exists, but the return information is adequately described. Given low complexity (2 params), it 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 clear parameter descriptions. The description adds only generic context ('for a task type') and does not enhance understanding beyond the schema. Baseline score 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 states the tool's function: 'Get a model recommendation for a task type without running inference.' It specifies the output (best free model, strengths, speed tier, alternatives), distinguishing it from siblings like compute.models or compute.route.

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: 'Use this when an agent needs to select a model before committing to inference, or to surface model selection logic to a human.' It does not explicitly exclude cases but gives clear guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering core behavioral traits. The description adds value by specifying the return content (model IDs, provider, etc.), which supplements the annotations 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 extremely concise: two sentences with no wasted words. It front-loads the main purpose and adds key details (free-tier, OpenRouter, return fields, usage context) efficiently.

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

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

Given the tool's simplicity (no parameters, no output schema, but clear annotations), the description is complete. It tells what the tool does, what it returns, constraints (free-tier), and when to use it relative to siblings.

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

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

No parameters exist (0 params, schema coverage 100%), so the baseline is 4. The description does not need to add parameter info, and it doesn't. It correctly omits any unnecessary detail.

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: listing all AI models available through DPX Compute. It specifies the returned fields (model IDs, provider, capability strengths, context window, speed tier) and explicitly distinguishes itself from the sibling tool compute.route by advising to use this tool before routing.

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 guidance: 'Use this before compute.route to understand what models are available and pick the right one for a task.' It also notes all models are free-tier, which helps the agent decide when to use 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 provide readOnlyHint=false and destructiveHint=false, and the description adds behavioral details: model selection based on task type, free-tier, payment via x402. It does not cover failure behavior or latency, but overall discloses key traits beyond 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?

Four concise sentences with front-loaded core action, no filler. Every sentence adds value: what it does, model selection, cost, and when to use.

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 no output schema, so the description should fully explain the return value. It says 'returns the completion' but does not specify format or structure. For an inference tool, this leaves ambiguity about the response shape.

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 adds meaning beyond the schema: explains how 'task' is used for model selection, notes 'messages' is optional, and clarifies 'preferSpeed' overrides default. This enhances understanding without repeating 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 routes a task to a free AI model and runs inference, with specific verb 'Route' and resource 'task to AI model'. It differentiates from sibling tools like compute.cost and compute.models by explaining model selection logic.

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 states 'Use this when an agent needs to delegate a subtask to a language model without managing model selection or API keys', providing clear usage context. It does not mention when not to use or alternative tools, but the purpose is sufficiently clear.

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 destructive and non-readOnly behavior. The description adds valuable context about the execution pipeline ('oracle gate → compliance screen → settlement flow') and states a receipt is returned. It does not mention reversibility or sandbox defaults, but the annotations provide the core safety profile, so this is solid rather than exceptional.

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 four sentences, each earning its place: purpose, when-not-to-use, process, and when-to-use. It is front-loaded with the primary action and avoids redundancy, making it appropriately sized for a payment tool with this complexity.

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

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

For a payment tool with multiple parameters, annotations, and an output schema, the description covers trigger context, execution flow, and return value (receipt). The sandbox default is documented in the schema, so the overall tool definition is complete enough for an agent to select and invoke 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 every parameter clearly documented. The description reiterates 'describe what you see, provide the amount and recipient' but adds no information beyond what the schema already provides. Baseline 3 is appropriate since the schema carries the full parameter burden.

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-resource pair ('Complete a payment') and scopes it to 'Claude's computer use session has identified on screen,' distinguishing it from sibling tools like invoice.pay and settlement.execute by the computer-use context. It also lists concrete UI examples (checkout form, wire transfer, invoice approval, vendor portal) that make the purpose 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 explicit when-to-use guidance: 'Use whenever computer use encounters a payment that would otherwise require human re-entry or approval.' It also provides a clear alternative behavior ('Call this instead of typing credentials into a UI'), and the schema adds a specific tool alternative (settlement.nl) for bank/email-only recipients.

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, and non-destructive behavior. The description adds meaningful context beyond annotations by stating the data is 'pulled directly from production telemetry' and that 'No auth required,' informing the agent about the data source and access requirements. 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 three sentences long, front-loaded with the core purpose, then elaborates on returned data and contextual details. Every sentence contributes substantive information without redundancy, making it appropriately concise and well-structured.

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 is not required to explain return values. It covers purpose, content, use cases, data source, cost, and authentication, providing complete 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 provides 100% coverage for the single optional parameter (window), including enum values and default. The description does not add any parameter-specific details, so the baseline score of 3 applies given the schema already handles the semantics.

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

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

The description clearly states the tool returns live performance metrics for the DPX settlement infrastructure, enumerating specific output categories (request volumes, error rates, growth trends, per-service breakdown, spike analysis). It distinguishes itself from generic siblings like analytics.overview by focusing on DPX-specific production telemetry data.

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 intended use cases ('designed for investor due diligence, analyst queries, and Standard Metrics / portfolio management integrations') and notes that no authentication is required. However, it does not explicitly mention alternative tools or provide when-not-to-use guidance, so it stops short of full exclusion 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?

Annotations already declare read-only and non-destructive. The description adds key behavioral details: limit of 50 entities, GLEIF resolution for names, slower performance for names, and output ranked by composite ESG score descending. This goes well beyond annotation coverage, giving the agent a clear model of runtime 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?

Five short sentences pack all crucial information without redundancy: function, inputs, output, use cases, and caveat. Every sentence earns its place, and the structure front-loads the core action then expands contextually.

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 batch screening tool with an output schema, the description covers capacity, input resolution trade-offs, ranking behavior, and use cases. It is sufficiently complete for an agent to correctly select and invoke the tool without 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?

The schema already describes both parameters in detail (LEIs as fastest, names via GLEIF slower with ≤3s per name). The description adds the combined batch limit ('up to 50 entities') and clarifies that inputs are alternatives, providing extra relational context beyond the schema's per-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 uses a specific verb 'Screen' with a clear resource (up to 50 entities), defines input types (LEIs or names), and states output ranking. It clearly distinguishes from sibling tools like esg.lookup or esg.portfolio by emphasizing batch screening and their composite ESG score ranking.

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 lists use cases ('portfolio-level compliance screening, supplier due diligence, TMS pre-payment checks') and provides practical guidance on input choice ('Name resolution is slower than direct LEI input'). However, it does not explicitly name alternative tools or when not to use it, leaving some differentiation to the agent.

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, and non-destructive behavior. The description goes beyond by detailing the return composition (pillar weights, composite score, fee tier, and per-source breakdown), giving the agent concrete insight into what the tool produces. No contradictions 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 four sentences, each with a clear purpose: core action, value proposition, detailed output, and usage condition. It is front-loaded with the primary verb and resource, and no sentence is redundant or unnecessary.

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 moderate complexity (3 params, 1 required) and the presence of an output schema plus rich annotations, the description is complete. It explains when to use it, what it returns, and the optional inputs are well-covered by the schema. The sources list and weight breakdown add useful context not required by the output schema.

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

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

Schema coverage is 100%, and each parameter already includes rich descriptions (e.g., examples for 'q', ISO-2 format for 'country', and narrative behavior for 'narrate'). The description adds no additional parameter-level semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb-resource pair: 'Resolve a company name, domain, or ticker to a LEI via GLEIF and return the full ESG score.' It clearly states the tool's function and distinguishes it from siblings by emphasizing it removes the need for a LEI, making it the go-to when only a name/domain/ticker is available.

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 final sentence provides an explicit usage condition: 'Use when you have a company name but not a LEI.' This implies when-not (if you already have a LEI, another tool is needed), but it does not explicitly name alternative sibling tools. Thus it gives clear context without full alternative listing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to cover safety. It adds the 200-entity cap and a detailed list of return values, but it does not disclose behavior for missing entities, error handling, or rate limits. This is adequate but not rich.

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

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

The description is concise: two sentences front-loaded with the main action and scope, followed by a list of return values. Every sentence provides useful information with no redundancy or 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?

The tool has no required parameters, a rich output schema, and strong annotations. The description covers the main purpose, limits, and return items, making it adequate for most use cases. It could be improved by mentioning edge-case behavior (e.g., unresolvable names), but the existing output schema and annotations fill many gaps.

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

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

Schema description coverage is 100%, with each parameter having a clear description. The tool description adds minimal information beyond schema (e.g., 'by LEI or name'), so it does not significantly enhance parameter understanding. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Score an entire counterparty portfolio in one call' with specific limits (up to 200 entities by LEI or name). It distinguishes itself by focusing on portfolio-level scoring, but it does not explicitly differentiate from sibling tools like esg.score or esg.batch.

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 context for when to use the tool: 'The canonical pre-settlement compliance check for treasury systems and TMS integrations.' This implies usage in a specific workflow, but there is no explicit mention of when not to use it or alternatives that might be more appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds substantial behavioral transparency beyond these: it discloses the exact return fields (ESG scores 0-100, composite average, settlement fee percentage), update frequency (hourly), and data sources (6 institutional sources). This enriches the agent's understanding of data freshness and provenance.

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

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

The description is four sentences, front-loaded with the primary purpose. Each sentence adds value: function, return values, update/data sources, and regulatory context. It is slightly dense with the list of data sources and regulations, but no sentence is wasted, and it remains compact for the amount of useful context provided.

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

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

For a tool with one optional parameter, rich annotations, and an output schema, the description is remarkably complete. It covers what the tool returns, how fresh the data is, where it comes from, and why it matters for compliance. Sibling differentiation is implicit but sufficient, and the absence of parameter detail is acceptable given the schema and output schema carry that load.

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

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

Schema description coverage is 100% for the single 'address' parameter, with a detailed description ('Wallet address (0x...) to score. Omit for protocol default.'). The description restates this ('for a wallet address or the protocol default') but adds no new syntax or format details, so it meets the baseline of 3 without surpassing it.

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: 'Get the live counterparty risk score (ESG-denominated) for a wallet address or the protocol default.' This specific verb+resource combination distinguishes it from siblings like esg.portfolio or esg.trend, which likely target different scopes (portfolio-level or time-series).

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: for a single wallet address or protocol default, and mentions regulatory use cases (EU SFDR, CSRD). However, it does not explicitly mention alternatives or when not to use it (e.g., for batch or portfolio scoring), so it falls short of a full 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 read-only/idempotent/non-destructive, so the description doesn't need to restate safety. It adds valuable behavioral context: data accumulates from esg.lookup, esg.batch, or esg.portfolio, and it enumerates trend direction values and delta, which helps anticipate response semantics.

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, each earning its place: purpose, return values, and data source/use cases. No fluff, front-loaded with the core action, and efficiently structured.

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, the description doesn't need to explain return structure in detail. It covers purpose, inputs, data accumulation, and use cases, making it complete for an agent to decide when and how to invoke this tool.

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

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

Schema description coverage is 100%: both 'lei' and 'days' have detailed descriptions. The description adds no further parameter syntax or format details beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the verb ('Get'), resource ('historical ESG composite trend'), and input ('by LEI'). It also specifies return values (score history, trend direction, delta), distinguishing it from sibling ESG tools like esg.score or esg.lookup that likely return current or individual scores.

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 lists use cases (due diligence, MiCA Article 72 monitoring, detecting degrading posture) and explains data accumulation via other tools, implying it should be used after scoring events. While it doesn't explicitly state when not to use it or name alternative tools, the context is clear.

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 are all false, providing minimal behavioral signal, so the description carries a heavy burden. It compensates well by disclosing daily check frequency, the threshold trigger (≥ thresholdPoints), webhook payload contents, and the returned watchId. It does not discuss error conditions, authentication, or duplicate-watch side effects, but the core behavioral traits are well covered.

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 three sentences, each serving a distinct purpose: registration action, monitoring behavior and trigger, and return value. Every sentence earns its place, 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?

The tool has moderate complexity with three parameters and an output schema. The description covers the registration action, monitoring cadence, trigger condition, output identifier, and webhook payload structure. Since an output schema exists, the description exceeds the requirement and provides a complete picture for selecting and 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 description coverage is 100%, with clear descriptions for lei, webhookUrl, and thresholdPoints. The description reinforces thresholdPoints by mentioning the shift condition but adds no new semantic information beyond the schema. Baseline 3 is appropriate since the schema already 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 description opens with a specific verb and resource: 'Register an entity for ongoing ESG monitoring'. It clearly distinguishes itself from sibling tools like esg.lookup, esg.score, and esg.trend by emphasizing ongoing monitoring with daily checks and webhook events, and by referencing MiCA Article 72 compliance.

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 the tool: when ongoing ESG monitoring with webhook alerts is required, particularly for MiCA compliance. However, it does not explicitly name alternatives or state when not to use this tool (e.g., for one-time score checks), so it lacks explicit exclusion 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?

While annotations already declare the tool read-only and non-destructive, the description goes further by disclosing that it uses the current DPX all-in rate (~2.035% typical), returns dollar savings, and includes GENIUS Act and MiCA compliance status for each competitor. This adds material context beyond structured annotations about the tool's dynamic behavior and output richness.

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, packed with specific details (fee ranges, typical rate, compliance status) with no fluff. Every clause adds value, and the structure efficiently conveys purpose and outputs.

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 comparison tool with multiple competitors and an output schema, the description adequately conveys the core functionality, output specifics, and the dynamic rate aspect. The existence of an output schema means it need not detail return fields, and the description covers the essential context for an agent to decide when and how to use 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 each parameter (hasFx, esgScore, amountUsd) already explained in the input schema. The tool description does not add parameter-specific semantics; it only mentions the output. With full schema coverage, 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 uses a specific verb ('Compare') with a clear resource ('DPX settlement cost') and explicitly enumerates the comparison set (Stripe, Wise, Ripple ODL, etc.). It clearly distinguishes itself from sibling tools like fees.schedule and fees.verify by focusing on comparative analysis rather than schedule display or verification.

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's use case—when you need to compare DPX costs against alternative rails—through its explicit comparison framing. However, it does not state when not to use it or name alternative tools for specific sub-tasks (e.g., obtaining a simple fee schedule), making the guidance clear 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds context about the content scope but does not disclose behavioral traits such as data freshness, pagination, or rate limits. This is adequate but not exceptional.

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

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

A single sentence that is information-dense yet well-structured, with the main purpose front-loaded and subsequent details clearly enumerated. Every word adds value, making it an optimal length.

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 informational tool with an output schema, the description covers all relevant aspects: the full schedule, discount tiers, ESG table, examples, and benchmarks. There are no missing elements that would impede correct tool selection or 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?

The tool has zero parameters, and the schema is empty. The description properly focuses on the output content, which is all that is needed. Baseline of 4 is appropriate for parameterless tools.

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 ('Get') and resource ('complete DPX fee schedule'), and enumerates the exact contents (components, tiers, ESG table, examples, benchmarks). This clearly distinguishes it from sibling tools like fees.compare and fees.verify.

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 clearly implies when to use this tool: whenever the complete fee schedule with tiers and benchmarks is needed. However, it does not explicitly mention when not to use it or direct to alternative fee-related tools, 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 establish read-only and idempotent behavior. The description adds valuable context about comparing off-chain quotes to the on-chain contract and the return value, which is useful. No contradictions.

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 concise sentences that front-load the core purpose, state the return value, and provide sequencing guidance. 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?

For a simple verification tool with full schema annotations and an output schema, the description adequately explains the tool's role and invocation context. The placement between get_quote and settle gives a clear operational flow.

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 documents each parameter. The description does not add extra meaning beyond mentioning the fee quote verification, so it meets the baseline without enhancing parameter understanding.

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: verifying that the off-chain fee quote matches the on-chain DPXSettlementRouter charge. It also distinguishes it from sibling fee tools by focusing on verification rather than comparison or scheduling.

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 provides explicit context: 'Call after get_quote and before settle to confirm fee integrity.' This clearly indicates when to invoke the tool, though it does not mention alternatives or exclusion scenarios.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral context: it runs checks 'in parallel', returns a 'go/no-go decision', and provides a 'ready-to-use settleBody'. These details go beyond the safety annotations, though it doesn't cover rate limits or auth.

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 worded sentences, front-loaded with the core purpose, followed by the internal actions and return fields. Every sentence earns its place, and there is no redundant or filler content.

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

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

Given the tool's moderate complexity and the existence of an output schema, the description sufficiently covers what the tool does, what it returns, and how it fits into the settlement workflow. It lacks some nuance (e.g., meaning of HOLD vs BLOCKED) but is complete enough for an agent to select 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%, so the schema fully documents all five parameters. The description doesn't add any new meaning beyond the schema; it only references 'amount' implicitly via 'settling' and mentions the compliance screen, which aligns with schema descriptions for address/lei. 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?

Description clearly states a specific verb+resource: 'Single pre-flight call before settling' that runs three named checks (oracle, compliance, stablecoin routing) and returns a unified decision. It explicitly replaces the 3-step oracle → screen → route loop, distinguishing it from sibling tools.

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

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

The description gives clear context for when to use it: 'before settling', and explicitly mentions it replaces the separate 3-step loop. It doesn't explicitly say when not to use it or list alternative individual check tools, but the primary use case is well defined.

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 substantial behavioral context beyond annotations: it returns exactly 12 windows, sorted by urgency with active windows first, and includes affected commodities, severity, and agronomic basis. This complements the read-only, idempotent annotations 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?

Two sentences front-load the primary purpose and then efficiently detail the return structure and sorting logic. Every word adds value, with no redundancy or 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?

For a zero-parameter, read-only tool with an output schema, the description fully covers what the agent needs to know: what the calendar is, what it contains, and how it is ordered. No critical information 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters; it instead focuses on the output, which 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 states the tool's function: a seasonal climate event calendar with commodity impact. It specifies the resource (calendar), the action (returns 12 annual windows), and provides specific examples (hurricane season, corn pollination) that distinguish it from sibling forecast tools.

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

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

The description implies usage context for retrieving seasonal climate windows and their commodity impact. It does not explicitly name alternatives, but the focused scope and details of the return data provide clear context for when this tool is relevant.

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 mark readOnlyHint=true and destructiveHint=false, so the description adds value by disclosing cache behavior (4h), the fresh parameter option, the return structure, and a disclaimer ('not a financial recommendation'). It does not fully characterize data limitations or broader behavioral nuances, but with annotations covering the safety profile, this is solid.

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

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

Four tight sentences, each earning its place: purpose, output detail, commodity coverage, audience/caveat, cache policy. Front-loaded with the core verb and resource, zero 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?

Despite having an output schema (so return values needn't be elaborated), the description goes further by listing covered commodities, cache lifecycle, and intended audience. With only 2 params (1 required) and enum constraints, this description fully covers the decision space for an AI agent selecting and 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% for both parameters, so the baseline is 3. The description adds meaning by explicitly mentioning 'Cache: 4h' and implying the fresh parameter bypasses this cache, complementing the schema description for 'fresh'. This goes beyond merely restating 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+resource: 'Climate-driven price pressure outlook for a commodity', and details the output (BULLISH/BEARISH/NEUTRAL signal, horizons, confidence, region breakdown, FRED price). It also lists the 11 covered commodities, distinguishing it from siblings like forecast.scenario and forecast.portfolio_stress.

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 clear context: 'Designed for institutional research teams evaluating commodity positions' and notes the climate/supply-constraint focus. However, it does not explicitly state when not to use it or contrast with alternative forecast tools (e.g., forecast.scenario), so it lacks explicit exclusions.

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, destructiveHint), the description discloses behavioral traits: it accepts up to 20 positions, normalizes weights internally, and returns a specific set of outputs (aggregate score, stressed positions, hedges, plain-language summary). This adds practical context about the tool's operation and results without contradicting 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 concise and well-structured: it states the purpose, input constraints, output details, and intended use case in four sentences. Every sentence contributes essential information without redundancy, and it is front-loaded with the primary 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 moderate complexity (one parameter, an output schema, and clear annotations), the description covers inputs, outputs, and usage context well. It does not explain the deeper methodology of 'climate stress test' but that is not necessary for tool selection and invocation. The presence of an output schema further reduces the need to describe return values.

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 provides descriptions for both parameters, the description adds meaning by clarifying that weights can be percentages or fractions and are normalized internally. This supplements the schema's statement that weights are normalized to sum to 1.0, giving the agent additional context about input flexibility.

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 a specific verb+resource: 'Climate stress test for a multi-commodity portfolio.' It states the primary function, the object (portfolio), and the specialized domain (climate). This distinguishes it from sibling tools like forecast.commodity_outlook or forecast.scenario by explicitly focusing on portfolio-level climate stress assessment.

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 use case: 'Useful for commodity fund managers evaluating aggregate climate exposure before rebalancing.' This gives context for when to use the tool, but does not explicitly mention alternatives or when not to use it. Since it offers a specific scenario without exclusions, it earns a 4.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool's safety is clear. The description adds useful behavioral context beyond annotations by explaining that results are ranked by a current climate risk score and that each region maps to affected commodities with HIGH/MODERATE/LOW risk levels. This meaningfully supplements the structured metadata.

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 most important information (what the tool returns) and followed by a practical use case. Every phrase earns its place, with 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?

The tool has a simple signature (no params), an output schema exists, and strong annotations are present. The description fully covers the tool's purpose, output content, and intended use, making it sufficiently complete for an agent to select and query 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, and the schema coverage is 100% by default. The description does not need to explain parameters, and the baseline of 4 for zero-parameter tools is appropriate as it focuses on what the returned data represents.

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 that the tool returns all ~40 global commodity production regions ranked by climate risk score, and specifies the output includes affected commodities and risk levels. This distinguishes it from sibling forecast tools like forecast.commodity_outlook by focusing specifically on production regions and geographic exposure.

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 to identify which geographic zones are under active climate stress and which commodities are most exposed,' giving clear guidance on when to invoke the tool. It does not mention exclusions or alternative tools, but the use case is unambiguous for a read-only list tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that it shows 'how signals shift' but does not detail response format or data freshness. The scenario list is more parameter semantics than behavioral 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?

The description is two sentences plus a scenario list. The first sentence is a clear subject-verb-object statement, the use case is stated at the end, and every element (including the scenario enumeration) 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 read-only analysis tool with full schema coverage and an output schema, the description is adequately complete. It covers the purpose, input modes (scenario vs overrides), and intended use, though it does not elaborate on output interpretation or alternative 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?

The input schema already provides 100% description coverage for all three parameters, including enum values and the note for symbols. The description adds a high-level explanation of named vs custom stressors but does not explain parameter syntax 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 it is a 'What-if climate scenario analysis' that applies scenarios to commodities and shows signal shifts. It lists specific built-in scenarios and the use case ('stress-test a commodity thesis'), distinguishing it from sibling forecasting tools like forecast.portfolio_stress by focusing on commodity-specific climate impact.

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 suggests using it to 'stress-test a commodity thesis before committing to a position,' providing clear context. It implies use for commodity-specific scenario analysis rather than portfolio-level stress, but does not explicitly name alternatives or exclusions.

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. The description adds valuable behavioral context including the sort order (OPTIMAL → ADVERSE), the 'Free' access note, and the completeness guarantee ('All 60+ corridors'), which go 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 four sentences, each adding distinct value: scope/data, sort order, use case with example, filter, and cost. No fluff or repetition, making it highly concise and 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?

With an output schema present, the description doesn't need to explain return values. It adequately covers scope, sorting, usage, filtering, and cost, which is complete for a simple read-only tool with one optional parameter.

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

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

The schema description for the 'from' parameter is 100% covered, so the baseline is 3. The description's 'Filter by source currency' adds little beyond the schema's own description, though it does reinforce the parameter's purpose.

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 returning all 60+ currency corridors with specific fields (stability tier, daily volatility, regulatory flags). The 'All' scope is a specific resource, and the data fields distinguish it from sibling tools that focus on individual rates or stability assessments.

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 explicit usage context: 'Use to compare corridors before choosing a payment route' and provides a concrete example query. However, it does not mention alternative tools 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?

Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context: the tool requires an x402 micropayment and produces a specific set of outputs (exact received amount, 48h variance, corridor stability, execution window). 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 three sentences and front-loaded with the core purpose. It is efficient, though some phrasing is buzzword-heavy ('CFO-grade', 'corridor stability overlay') and could be tightened without losing meaning.

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 covers the essential behavioral context: purpose, key output dimensions, cost requirement, and the question it answers. It lacks explicit detail about data freshness or execution latency, but overall it is sufficiently complete for a tool of this complexity.

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

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

The schema covers 100% of parameters, so the baseline is 3. The description reinforces the meaning of amount and target currency by framing the question, but it does not add parameter-specific details beyond what the schema already provides.

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

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

The description clearly identifies the tool as an all-in settlement cost quote for cross-border payments and states the exact question it answers: what the counterparty receives net of fees and how certain that number is. This is specific and distinguishes it from sibling tools like fx.rate or settlement.quote.

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 usage context (when sending a cross-border payment and needing cost certainty) and notes the x402 micropayment requirement. However, it does not explicitly compare to alternatives or state when not to use it.

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

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

Annotations already flag read-only, idempotent, non-destructive. Description adds valuable context: data sourced from open.er-api.com (central bank rates), hourly updates, no API key required, free. 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 sentences: first gives purpose and returns, second gives source and access. Front-loaded, every clause earns its place, no 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?

Tool is simple, has output schema, full schema coverage, and annotations. Description covers data source, freshness, auth, and return fields, making it complete for 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 covers both parameters with ISO 4217 descriptions and examples (100% coverage). Description does not add beyond 'any currency pair', so 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?

Description states 'Live mid-market FX rate for any currency pair' – a specific verb and resource with clear scope. It distinguishes from siblings like fx.corridors and market.fx by focusing on the mid-market rate and listing returned data fields.

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?

Clearly implies when to use: 'for any currency pair' and source details (central bank rates) but does not explicitly name alternatives or exclusions. Sibling tools like fx.corridors exist but no comparison is made.

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 read-only and idempotent behavior. The description adds valuable context beyond this: it polls Base mainnet for a specific payment, returns 'pending' until detected, then 'verified' with a txHash and Basescan link. This fully discloses the tool's operational behavior with no contradictions.

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, each with a clear role: purpose, behavior, and polling recommendation. No wasted words, and the most important information is 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 simplicity (one parameter, output schema present, annotations provided), the description fully covers the state transitions, return content, and appropriate polling cadence. It is complete for an agent to use 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%, with the id parameter described as 'verificationId returned by integration.verify.' The description adds no additional parameter semantics beyond this, but the schema handles it fully, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Check the status of a DPX integration verification session.' It clearly distinguishes from sibling tools like integration.verify, which initiates verification, and settlement.status, which pertains to settlements.

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 the tool: poll after sending the $0.01 USDC handshake payment, every 10–15 seconds. It does not explicitly mention when not to use it or name alternative tools, but the usage pattern is well 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?

With all annotations false, the description carries the transparency burden and does a decent job: it discloses the exact amount and network, that the client sends the payment, what the tool returns, and the required next step. It does not mention whether the call creates a persistent record or discuss rate limits/authorization, which prevents a 5.

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

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

Four short sentences each add meaningful information: what the tool does, return value, client action, and follow-up/requirement. The description is front-loaded and contains 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?

For a simple onboarding handshake tool, the description is complete: it explains the workflow, the Base mainnet context, the amount, the follow-up call, and the production prerequisite. The presence of an output schema and rich input schema means the description does not need to restate return structures.

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 already provides 100% parameter descriptions, including the wallet address role and the API key hashing behavior, so the description adds little parameter-level information. The baseline of 3 applies because 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 description uses a specific verb ('Initiate') and resource ('DPX integration onboarding handshake') and clearly states its purpose: verify wallet funding via a $0.01 USDC transfer. It also distinguishes the tool from the sibling integration.status by naming that tool as the polling step.

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 ('Required for all new integrations before production settlements are enabled') and names the follow-up alternative ('Call integration.status to poll for confirmation'). It does not explicitly state when not to use it or list other sibling alternatives, 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, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by detailing the three wave time horizons and the type of analysis (rebounding, amplified pressure, structurally altered). This goes beyond the structured 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 moderately detailed but well-structured, front-loading the purpose and then explaining the wave outputs and usage sequence. Every sentence adds value, though the POST note is somewhat redundant with schema.

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

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

Given the presence of an output schema and strong annotations, the description provides sufficient context: it explains the tool's role, the wave structure, and the companion relationship with market.cascade. It does not describe the return format in detail, but that is covered by the output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions origin, eventType, magnitude, and elapsedHours in context, but does not add substantial meaning beyond the schema. It notably omits horizonHours, which is already well-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 tool models secondary waves following a primary cascade event, with specific outputs (Wave 1, Wave 2, Wave 3). It names the companion tool market.cascade but does not explicitly differentiate from other intelligence.* siblings like contagion or resonance, so it lacks full sibling distinction.

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 sequencing guidance ('run cascade first, then aftershock') and describes the intended scenario (modeling aftershock waves). It does not list alternatives or exclusions, but the context is clear enough for when this tool should be used.

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 substantial behavioral detail beyond the readOnlyHint/openWorldHint/idempotentHint annotations: it explains the epidemiological model, lists return payloads (R trajectory, spread map, superspreader nodes, containment forecast, AI briefing), and gives the R-value interpretation threshold. The 'POST' wording might superficially suggest mutation, but the simulation semantics and annotations align, so no 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 front-loaded block with dense but relevant sentences covering model, domains, outputs, threshold, and usage. It is slightly redundant by beginning with 'Contagion Intelligence' when the tool name already includes 'contagion', but overall 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?

For a three-parameter simulation tool with a full output schema and read-only/idempotent annotations, the description is very complete: it covers prerequisites, how to trigger node discovery vs simulation, parameter expectations, output highlights, and result interpretation. No critical operational 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 coverage is 100%, so the schema already documents origin, listNodes, and magnitude. The description adds domain context for origin selection and shows how listNodes acts as a discovery mode, but it does not materially expand parameter 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 tool as simulating contagion spread across 30 nodes and 6 domains using an R-value model, with specific outputs. It is more specific than a generic verb-resource pair, but it does not explicitly contrast with sibling shock-model tools like intelligence.aftershock or intelligence.resonance, so it falls short of a 5.

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

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

It provides a clear prerequisite ('Call /contagion/nodes first to discover valid origin IDs') and parameter guidance ('POST with origin and magnitude'), which establishes when to use the simulation branch vs the node-listing branch. However, it does not address when to prefer this tool over related forecasting tools or any exclusion cases.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate these. It adds valuable behavioral context beyond annotations: '12h cache', 'Live FRED economic stress feedback', and the two-score output with transmission mechanisms. This helps the agent understand the nature of the data and response. No contradictions 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 dense paragraph but is well-structured with an em-dash opener that front-loads the main purpose. Every sentence adds value: it explains the two scores, their meanings, data sources, cache behavior, and the absence of input. It avoids fluff, though it could be slightly more scannable with breaks, it remains 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?

Given that the tool has an output schema (as indicated by context signals), the description does not need to enumerate return fields. It adequately covers the domain, the two output scores, transmission mechanisms, data sources, and caching. The main gaps are that the 'five transmission mechanisms' are not enumerated and 'AI synthesis' is vague, but these are minor for a no-input GET 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, and the schema coverage is 100% (vacuously). The description explicitly states 'No input required — GET,' which reinforces that the agent can invoke the tool without any arguments. According to the calibration baseline for 0 params, this is an appropriate score.

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 and resource: 'maps the structural relationship between GBV prevalence, legal discrimination, female labour force participation, and economic outcomes across 18 countries.' It also distinguishes itself from sibling intelligence tools by focusing on gender risk, which is unique among the listed siblings. The purpose is unmistakable.

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: it is a standalone GET call with no input, designed to return gender risk and opportunity scores. It implies usage for assessing sovereign risk, FDI inflows, and economic reform potential. However, it does not explicitly mention alternatives or exclusions, though the tool's unique subject matter makes confusion unlikely.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. The description adds meaningful behavioral context beyond annotations: it specifies the tool returns per-signal phase angles, resonance clusters, amplification factor, a 0–100 score, and historical comparison to crisis precedents. It also states no input is required and uses GET, which aligns with the read-only nature. 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 compact yet information-dense. It front-loads the core purpose, explains the conceptual meaning of resonance, lists all major outputs, and ends with a clear usage note. Every sentence adds value without redundancy. It is appropriately sized for the tool's complexity.

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

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

Given the tool has no parameters, paired with annotations (read-only, idempotent, open-world) and an output schema (not shown but indicated), the description covers all essential aspects: what it does, what it returns, and how to invoke it. It even adds historical context with crisis precedents, making it self-contained for an agent. It is complete for its complexity level.

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, and the schema is empty with 100% coverage trivially. The description explicitly states 'No input required — GET,' which resolves any ambiguity about invocation. Since there are no parameters, the baseline for 0 params is 4, and the description adds the key fact that no input is needed, so no deduction needed.

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 ('detects') and resource (macro forces oscillating in phase across 28 signals in 5 domains). It further differentiates from sibling tools by focusing on resonance/amplification rather than cancellation, and lists precise outputs. This is more specific than typical tool descriptions and immediately conveys its unique role among intelligence tools.

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

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

The description implies when to use the tool (e.g., when multiple macro forces might be aligning to create systemic risk), but it does not explicitly contrast with sibling tools like intelligence.contagion or intelligence.aftershock. 'No input required — GET' is a usage method note, not a when-to-use guideline. There is no exclusion or alternative recommendation, so it falls short of explicit guidance.

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

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

Annotations are all false, so the description carries the transparency burden. It discloses key behavioral traits: the cron checks hourly, the trigger is edge-triggered (not repeated), and it returns a subscriptionId. This goes beyond the schema and gives agents an accurate mental model of the tool's execution. It does not cover retry/failure behavior, but the essentials are present.

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

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

Four sentences, zero redundancy. The purpose leads, followed by signal details, trigger cadence, return value, and use cases. Every sentence adds unique information without repeating schema fields 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?

For a 5-parameter subscription tool with no helpful annotations and an output schema present, this description is remarkably complete. It covers what the tool does, supported signals, trigger semantics, return value, and intended use cases. The absence of wire format details is acceptable given the output schema exists.

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 100% of parameters, providing a baseline of 3. The description adds meaningful context by explaining signal semantics: stability's 0–100 range, cascade as shock propagation risk, and the 'any' option. It also ties threshold to the 0–100 score and explicitly notes the edge-triggered behavior, which clarifies the threshold's semantics.

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

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

The description opens with a specific verb+resource: 'Register a webhook to receive alerts when a DPX intelligence signal crosses a threshold.' This clearly distinguishes from sibling tools like intelligence.subscription.delete/get, which are for management. The supported signals are enumerated, reinforcing the tool's scope.

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

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

The description closes with explicit use cases: 'Use for treasury alert systems, TMS integrations, or autonomous agent monitoring loops.' This gives clear context for when to apply the tool, though it does not explicitly name alternatives or exclusion criteria. The sibling tools suggest a natural alternative for cancellation/status (intelligence.subscription.delete/get), but they are not referenced.

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 disclose destructive and idempotent hints. The description adds valuable context: it stops 'future webhook alerts' while retaining 'the alert log for audit purposes.' This clarifies the exact scope of destruction, going 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?

Two concise sentences deliver the core function, effect, and an important retention detail. No redundant phrases or filler; 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?

For a simple one-parameter delete tool with annotations and an output schema, the description is complete. It explains what happens (cancellation), the consequence (no future alerts), and a key exception (log retained). Nothing essential 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?

The schema covers the single parameter fully, describing it as 'UUID returned by intelligence.subscribe.' The description only says 'by ID,' which adds no new semantic information. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Cancel an intelligence subscription by ID.' The verb 'Cancel' and resource 'intelligence subscription' are specific, and the description distinguishes it from siblings like intelligence.subscribe (creating) and intelligence.subscription.get (retrieving).

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 usage context: it stops future webhook alerts. It implies this is the tool to use when you want to terminate a subscription. However, it does not explicitly mention alternatives or when not to use it, 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 declare readOnlyHint and idempotentHint, covering safety. The description adds behavioral detail by listing what the tool returns (signal score, last fired timestamp, total alerts fired, subscription configuration) and its role in verifying subscription activation. It doesn't cover errors or rate limits, but with rich annotations and output schema, 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 two sentences, front-loaded with the purpose, and every word contributes. It efficiently covers what the tool does, what it returns, and when to use it.

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

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

This is a simple read-only tool with one parameter, an output schema, and strong annotations. The description provides purpose, return contents, and lifecycle context, making it complete for an agent to invoke correctly without additional 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%, and the parameter description ('UUID returned by intelligence.subscribe') is clear. The description merely restates 'by ID' without adding new semantic value beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Check the status of an intelligence subscription by ID.' It specifies the resource (subscription) and verb (check/status), and distinguishes itself from siblings like intelligence.subscribe and intelligence.subscription.delete by focusing on status verification.

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: 'Use after intelligence.subscribe to verify a subscription is active.' This tells the agent when to use the tool, though it doesn't explicitly mention exclusions or when to prefer alternatives. Since alternatives are clearly different (subscribe/delete), the guidance is sufficient for a status check tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds non-obvious behavioral details: the GET method, no input, return contents ('per-node stress state, rupture sequence, horizon timeline, and AI synthesis briefing'), and its focus on latent pressure. It is consistent with annotations and adds useful 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 description is four sentences, each carrying substantive information: mapping scope, node data structure, comparison to market.cascade, and output/request details. It is front-loaded with the core purpose and contains no filler or redundant statements.

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 are already formally defined. The description still adds rich context: the specific domains, node attributes, comparison to a sibling tool, and the request method. For a zero-parameter read-only tool, this is complete and eliminates 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?

With zero parameters and schema coverage at 100% (vacuously), the baseline is 4. The description explicitly states 'No input required — GET,' which reinforces the empty schema and prevents confusion. No further parameter semantics are needed.

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 function: 'maps slow-moving structural stress across 22 fault lines in 5 domains.' It specifies the resource and output detail, and explicitly distinguishes from market.cascade by contrasting acute shock vs. latent pressure. This is a specific verb+resource with sibling differentiation.

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

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

The description provides clear usage context by contrasting with market.cascade: 'Where market.cascade traces an acute shock, tectonic surfaces latent pressure before it ruptures.' It also states 'No input required — GET.' However, it doesn't explicitly compare with other intelligence.* siblings like intelligence.contagion or intelligence.resonance, so the exclusion guidance is partial.

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 operation returns invoiceId and payUrl, that it is a payment request rather than a direct transfer, and that invoices expire after ttlSeconds default 24h. Since annotations provide no safety hints, this description carries the burden well, though it omits potential side effects like fees or required preconditions.

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 three sentences, front-loaded with the primary action, then workflow, then expiration. Every sentence contributes unique information 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?

For a tool with 7 parameters and an output schema, the description covers the core workflow, return values, and expiry. It does not mention prerequisites or edge cases, but the context is sufficient for an agent to select and invoke correctly. Output schema handles return details.

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

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

All seven parameters have descriptions in the schema (100% coverage), so the description adds little beyond already-documented parameter semantics. It references ttlSeconds default, which is already in the schema, providing no additional value. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Create an agent-to-agent invoice' with a specific call pattern (Agent A requests payment from Agent B). It also distinguishes from sibling invoice.pay by explicitly naming it as the settlement step.

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 provides explicit usage context: 'Agent A calls this to request payment from Agent B' and instructs that Agent B calls invoice.pay with the returned invoiceId to settle. This clearly differentiates when to use this tool versus the sibling invoice.pay and describes the expected workflow.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds workflow context ('confirm the invoice is still OPEN') and enumerates the statuses, which conveys the intended read-only check behavior. 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: the first states the core function and return values, the second gives a workflow directive. Both sentences carry necessary information with no redundancy or 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?

For a simple read tool with a single parameter and an output schema, the description is complete. It covers the purpose, the exact use case, and key returned fields. Annotations handle safety and idempotency, so no further behavioral details are needed.

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%: the parameter invoiceId is fully documented as 'Invoice UUID returned by invoice.create'. The description only refers to 'by ID' and adds no additional parameter semantics beyond what the schema already provides. Baseline 3 is appropriate because 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 description uses the specific verb 'Retrieve' with a clear resource ('an agent-to-agent invoice by ID') and lists the returned fields (status, amount, currency pair, payUrl). It explicitly positions itself in the workflow by mentioning invoice.pay, which distinguishes it from sibling tools like invoice.create and invoice.pay.

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

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

The description states clearly when to use the tool: 'Use before calling invoice.pay to confirm the invoice is still OPEN.' This provides clear context and a specific workflow trigger. It does not explicitly name alternatives or when-not-to-use, but the placement before invoice.pay is a strong, unambiguous guideline.

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 behavior beyond the annotations: it retrieves the invoice, calls POST /settle, marks the invoice PAID on success, and explains sandbox vs live return behavior. This adds meaningful context about side effects and mode-dependent outputs. The annotations (readOnlyHint=false, destructiveHint=false) are consistent; no contradiction present.

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 with no filler. The first sentence states the primary action and key side effects; the second sentence efficiently covers mode-dependent behavior. All information is relevant and 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?

The tool has moderate complexity and an output schema, so return values need not be described. The description covers the core workflow (retrieve, settle, mark PAID), mode differences, and endpoint. It omits potential error handling or authorization details, but for this complexity level the description is reasonably 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%, so parameters are already documented. The description adds context around the sandbox parameter by explaining simulated vs live mode outputs, but it does not add detail about invoiceId or recipientAddress beyond the schema. This meets the baseline of 3 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 uses a specific verb and resource: 'Pay an agent-to-agent invoice by ID.' It clearly distinguishes from sibling invoice.get/invoice.create and settlement tools by focusing on the payment action and the 'agent-to-agent' scoping. The mention of settlement via POST /settle and marking PAID further clarifies 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?

The description makes the usage context clear: use this when paying an agent-to-agent invoice by ID. It explains the mechanics (retrieves invoice, settles, marks PAID) and covers sandbox vs live behavior. It does not explicitly mention alternatives or when NOT to use this tool, but the context is sufficiently clear for an AI to select it over siblings like settlement.execute.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond that: it specifies the return contents (total USD, transaction count, chronological list) and the scope (all payments during the session). No contradiction with annotations; it complements them well.

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 states the function and outputs, the second gives usage context. Every sentence earns its place, no clutter, and the most important information is front-loaded. Excellent conciseness.

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

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

For a simple read-only tool with a single parameter, the description covers the purpose, output contents, and use cases. Since there is no output schema, listing the return fields in the description helps fill that gap. It could have mentioned pagination or error conditions, but for this complexity level, it 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?

Schema coverage is 100% for the only parameter, session_id, which includes a helpful description ('the same ID used in receipt.create calls'). The tool description does not add additional parameter-level meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('aggregated payment graph for a multi-agent session'), and it clearly distinguishes what the tool does from siblings like receipt.create or analytics.overview. It also lists the exact outputs (total USD, transaction count, chronological list), making the purpose 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 explicitly states when to use the tool ('for cost accounting, audit, or to show a human what an agent run spent'). It doesn't mention alternatives or exclusions, but the use cases are clear enough to guide an agent in choosing it over similar tools. This is a solid 'use for' statement, though it lacks explicit '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?

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds meaningful detail about return structure (time-ordered chain, attenuated signal strength, AI synthesis briefing) and domain coverage. While it doesn't discuss rate limits or auth, annotations cover the safety profile, so the additional context is sufficient.

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 long and includes a detailed enumeration of all 24 nodes across 4 domains, which is largely redundant given the schema's instruction to call listNodes:true. The opening metaphor 'Butterfly Effect Cascade Intelligence' adds flourish but no functional value. It is information-dense but could be more concise.

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 is complex (5 optional params, multiple domains, cascade logic) and the description covers inputs, outputs, domain lists, discovery mechanism (listNodes), magnitude scale, horizon, and exclusions. The presence of an output schema means return values need no further detail. This is nearly complete for the tool's complexity.

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

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

Schema coverage is 100%, so the schema already documents all parameters thoroughly. The description mentions 'origin event and magnitude score' and provides examples, but these echo the schema's existing parameter descriptions rather than adding new meaning. It does not offer extra guidance beyond what the schema provides.

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

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

The description clearly states what the tool does: 'models how a shock in one macro domain propagates' and 'returns a time-ordered cascade chain'. It specifies the tool's scope (macro domains) and explicitly distinguishes it from stablecoin/settlement tools with 'Purely macro intelligence — no settlement or stablecoin mechanics'.

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 for use: analyzing shock propagation across climate, geopolitical, economic, and commodity systems. It provides a 'when-not' hint with the no-stablecoin exclusion, but it does not explicitly name alternative sibling tools or state conditions when this tool is preferred over others like intelligence.contagion.

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