DPX — Institutional Cross-Border Settlement

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

Annotations already indicate it is not readOnly (write operation), not idempotent, and not destructive. The description adds significant behavioral context: no documents required, instant tier grants for ANONYMOUS/REGISTERED, VERIFIED tier via GLEIF API call, caps clamped to tier limits, and no manual review. 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, well-organized paragraph that wastes no words. It front-loads the model name ('KYA — Know Your Agent') and then systematically covers each tier, requirements, caps, and legal basis. Every sentence adds essential information, making it both concise and 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?

Given the tool's complexity (8 parameters, nested mandate object, tier logic, external LEI verification), the description is comprehensive. It explains all key behaviors: tier requirements, caps, legal references, and the verification mechanism. The existence of an output schema (not shown) likely covers return value details, but the description does not mention error cases, which is a minor gap.

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

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

Schema description coverage is 100%, with detailed field descriptions. The tool description adds semantic value by explaining how parameters map to tiers (e.g., ownerEntity/ownerEmail required for REGISTERED, ownerLei for VERIFIED) and how the mandate behaves (caps clamped). This ties the parameters to the tier model beyond the individual schema 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 explicitly states 'KYA — Know Your Agent. Three-tier registration model' and details the specific tiers (ANONYMOUS, REGISTERED, VERIFIED). This clearly identifies the tool as an agent registration function, distinct from sibling tools like agent.kya_verify and agent.mandate_create, which handle verification and mandate creation respectively.

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 each registration tier by outlining requirements and caps (e.g., 'ANONYMOUS: agent name only, $1K/day cap, instant'). It implicitly tells users when to choose a higher tier (higher caps require more info). However, it does not explicitly exclude alternatives or contrast with sibling tools (e.g., when to use kya_verify instead of re-registering).

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 adds value by disclosing the credential expiration (1 hour), the requirement to attach headers, and the specific return fields. There is no contradiction with annotations. The description provides behavioral context beyond the annotations, such as the need to refresh and the effect on /settle requests.

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: first sentence states purpose, second lists return values, third gives usage instructions and expiry. It is front-loaded, efficient, and every sentence provides essential information without redundancy. 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?

Given the tool's simplicity (1 parameter, output schema present, annotations), the description covers purpose, return values, header attachment, and refresh requirement. It does not mention error cases or prerequisites (e.g., agent must be registered), but the output schema likely handles errors. Overall, it is sufficiently 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% with one parameter (agentId) described in the schema as 'Agent ID from agent.kya_register (agt_...).' The description repeats this same information and adds no new meaning beyond the schema. With high coverage, the baseline is 3, and the description does not elevate 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 purpose: 'Verify a registered DPX agent and receive a signed 1-hour credential.' It uses a specific verb ('Verify') and resource ('registered DPX agent'), and the return values are enumerated. The sibling list includes agent.kya_register (registration) and agent.mandate_create (mandate creation), which are distinct; the description implies this is for agents already registered, so it distinguishes itself.

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 explains when to use the tool: it produces a credential that must be attached to DPX /settle requests, and it states 'call again to refresh before expiry.' This provides clear usage context. However, it does not explicitly contrast with other tools like agent.kya_register or provide scenarios where it should not be used, so it misses some exclusion 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 indicate readOnlyHint=false, which is consistent with a write operation. The description goes beyond annotations by explaining tier-based cap clamping (REGISTERED $25K, VERIFIED no ceiling), expiry, and AP2 formatting. This adds significant behavioral context not available in annotations alone.

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, front-loading the core purpose. Every sentence adds value, no fluff. It efficiently communicates constraints, prerequisites, and interoperability.

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 8 parameters, 3 required, and existing output schema, the description covers agent eligibility, tier caps, counterparty list, currency pairs, ESG floor, and expiry. It is complete for a complex financial tool, leaving no major gaps in context.

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 baseline is 3. The description adds meaning by explaining how parameters relate to agent tiers (e.g., maxNotionalUsd clamped for REGISTERED, no ceiling for VERIFIED), which enriches the schema descriptions.

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

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

The description clearly states the tool creates or updates an AP2-compatible spend mandate for registered or verified DPX agents. It uses specific verbs ('Create or update') and resource ('spend mandate'), and differentiates from siblings like reg, verify, settle by focusing on mandate setup constraints.

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 on when to use (for registered or verified agents) and when not (anonymous agents), and includes prerequisites (register with ownerEntity+ownerEmail). However, it does not explicitly name sibling tools as alternatives, which is a minor gap.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds value by specifying the exact data fields returned (stability score, ESG composite, fee breakdown, oracle health, settlement readiness) and emphasizing the 'live' nature. This is sufficient beyond the annotations, though it could mention caching or refresh 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 two sentences long, front-loaded with the primary purpose, and wastes no words. Every sentence adds value: the first explains what the tool returns, the second states 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?

Given the tool has no parameters and an output schema exists (not shown but referenced), the description covers the main return components comprehensively. It is fully adequate for an agent to understand the tool's purpose and output without needing further elaboration.

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 schema description coverage is 100%. The description is not required to explain parameters, but it still provides context for what the output will contain. A score of 4 reflects the baseline for no-parameter tools where the description adds value beyond the schema.

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

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

The description uses a specific verb ('Get') and resource ('live DPX performance analytics'), and lists concrete components (stability score, ESG composites, fee breakdown, oracle health, settlement readiness). This clearly distinguishes it from sibling tools that target narrower metrics (e.g., dpx.metrics, esg.score, oracle.stability).

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 its intended use cases: 'Use for dashboards, reporting, and AI-driven monitoring of protocol health.' This gives clear context for when to invoke it. However, it does not mention when not to use it or directly name alternative tools for more granular queries, which would strengthen the guidance.

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

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

The description adds critical behavioral context beyond the annotations: concurrency, non-blocking failure, and the structure of the response (summary + per-item results). Annotations are minimal (readOnlyHint=false, etc.), so the description fully shoulders the transparency burden.

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, zero wasted words. The first sentence states the purpose, the second explains behavior, the third describes the output and constraints. Every sentence earns its place.

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

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

Given the tool's complexity (batch operation with nested objects), the description covers purpose, concurrency, failure handling, response summary, and max size. The presence of an output schema further reduces the need for return value details. The description is complete and actionable.

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 input schema has 100% coverage (parameter 'settlements' described), the description adds significant meaning: concurrency semantics, failure handling, response shape, and batch limit. This goes well beyond the schema definition.

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 starts with a clear verb+resource: 'Submit multiple settlements'. It immediately distinguishes this tool from single-settlement tools by its batch nature. The purpose is specific and unambiguous.

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

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

The description explicitly states when to use this tool (multiple settlements), how it behaves (concurrent, failure isolation), and includes a hard limit ('Maximum 50 per batch'). While it does not name sibling tools, the purpose alone makes the use case 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context by explicitly stating 'No settlement is executed' and describing the output format (optimal plan). 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 three sentences, front-loaded with the primary purpose. Each sentence earns its place: purpose, input/output specifics, and usage guidance plus cost indication. No fluff or redundancy.

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

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

There is no output schema, but the description explicitly lists what the tool returns: 'which corridors to settle now vs. hold, which stablecoin to use per corridor, and estimated all-in fee.' It also gives input examples and clarifies no execution occurs. This is complete for a read-only planning tool with strong annotations.

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

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

Schema description coverage is 100%, so both parameters are already well-documented. The description's example ('USD-BRL: $2.3M, USD-EUR: €450K') illustrates the positions format but does not add semantics beyond the schema, which includes the field names and example object.

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 verb 'Plan' and resource 'treasury settlement for a crypto card program' are specific and actionable. It explicitly distinguishes itself from card.settle by stating 'Call this before card.settle to review the plan', and it lists the concrete output (corridors, stablecoins, fee).

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 states when to use this tool: 'Call this before card.settle to review the plan.' It also clarifies the non-execution behavior ('No settlement is executed'), preventing misuse. It does not enumerate alternatives like batch_settle or settlement.quote, but the primary sibling is addressed.

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 valuable behavioral context beyond the annotations: compliance-gated, oracle-priced, stablecoin-routed execution, and sandbox default behavior. Annotations declare destructiveHint=false but the description clarifies that live execution only occurs with sandbox:false, aligning with the annotation. No contradictions found.

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 paragraph of moderate length covering essential points. It is efficient with no wasted words, though a slightly more structured layout (e.g., bullet points) could improve scanability.

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

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

Given no output schema, the description appropriately mentions return value type (per-corridor results and summary). It covers purpose, parameters, execution path, and sandbox mode. Minor gaps: missing error conditions, prerequisites (e.g., card.positions availability) and relationship to compliance checks.

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

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

Schema description coverage is 100%, and the schema already provides structured parameter descriptions. The description adds extra context: the positions array format aligns with card.positions, and recipientAddress is required per position. This adds value beyond the schema without redundancy.

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 'execute treasury settlement' and the resource 'crypto card program'. It references the sibling tool card.positions to define input structure, distinguishing itself by noting the execution path via DPX batch. However, it does not explicitly differentiate from similar settlement tools like batch_settle or settlement.execute, which slightly reduces clarity.

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 by stating it takes the same positions as card.positions and mentions sandbox mode for testing. However, it provides no explicit guidance on when to use this tool versus alternatives (e.g., batch_settle, settlement.execute), and lacks 'when not to use' or prerequisite conditions.

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 non-destructive. The description adds meaningful context: the data source (OpenSanctions), the risk level categories, and the compliance implication (EDD requirement). This goes beyond the annotation basics 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 concise, covering key aspects in three sentences. It front-loads the main action and purpose, then provides details on output and compliance implications. It could be slightly tighter by removing redundant phrases, but overall it's 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 the tool's moderate complexity, the description covers all essential aspects: purpose, data source, output details, risk levels, and regulatory implications. The output schema exists, so return values are already specified. This description is complete and sufficient for an agent to decide and invoke it correctly.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds the example 'Mario Draghi' and the ISO-2 country code format, but these are minor enrichments. The baseline 3 is appropriate since the schema already covers 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 it screens an individual by name against the OpenSanctions PEP dataset, lists the types of PEPs included, and specifies the output (confidence, role, nationality, related entities, risk level). This distinguishes it from compliance.ubo_chain and regulatory_calendar by focusing on PEP screening specifically.

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 clear context on when to use the tool (for PEP screening) and specifies that HIGH or MEDIUM matches require EDD per FATF recommendations, implying a compliance workflow. However, it does not explicitly state when not to use it or mention alternatives like ubo_chain for beneficial ownership checks.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds value by detailing the output structure (events with fields and a DPX alignment section), which goes beyond the annotations. 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?

The description is concise and well-structured, with a clear first sentence stating the purpose, followed by details on output fields and a DPX alignment section. Every sentence adds value, and there is no redundancy.

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

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

Given the tool has no parameters, is read-only, and has an output schema, the description is complete. It explains the content of the output and provides use cases. The output schema handles return value details, so no further explanation is 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?

The tool has zero parameters, so the baseline is 4 per the rubric. The description adds no parameter information (none needed) but compensates by explaining the output structure, which is semantically useful.

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 a structured calendar of compliance obligations, listing specific regulations (MiCA, SFDR, CSRD, GENIUS Act, FATF) and the fields per event. It differentiates itself from sibling tools like compliance.pep_screen by focusing on a calendar of obligations for regulatory planning.

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 this before settlement workflow design, compliance gap analysis, or regulatory reporting,' providing clear guidance on when to use the tool. It does not mention when not to use it or directly name alternatives, but the context is sufficient.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds significant behavioral details: traversal depth, specific sanctions lists (OFAC SDN, EU, UN, UK OFSI), return structure (chain, sanctions status, LEI lapse, verdict, FATF attestation). 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?

The description is a single paragraph of four sentences, front-loaded with the primary action. Every sentence provides essential information without redundancy. It is appropriately sized for the 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's complexity, the description covers the purpose, methodology, output structure, and compliance use cases. It mentions all key return fields (chain, status, flags, verdict, attestation). The output schema exists, so the description does not need to repeat every field.

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

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

Schema coverage is 100% with descriptions for both parameters (lei, deep). The description adds context by explaining the 'deep' parameter's effect (3-level vs. direct+ultimate) and implying the lei format. This adds value beyond the schema.

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

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

The description clearly states the tool traces the beneficial ownership chain up to 3 levels deep and screens nodes against sanctions lists. It specifies the verb 'trace' and the resource 'beneficial ownership chain', and distinguishes itself from siblings like compliance.pep_screen by focusing on UBO chain and sanctions.

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 lists required use cases: correspondent banking due diligence, FATF R.12/13 UBO identification, and MiCA Article 72 risk management. It does not mention when not to use or alternatives, but the context is strong enough for an agent to decide.

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 behavior. The description adds valuable behavioral context: it returns the 'best free model,' its 'strengths and speed tier,' and 'a list of alternatives,' and notes it is 'Free.' This clarifies the tool's output and cost implications 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 three concise sentences. Each sentence adds distinct value: what the tool does, what it returns, and when to use it. 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 simplicity (2 params, no output schema), the description is complete. It explains the returned data (strengths, speed tier, alternatives), the use case, and the 'free' aspect. No critical information appears 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% for both parameters ('task' and 'speed'), so the schema already documents them. The description mentions 'task type' and output 'speed tier' but does not add new parameter-specific meaning 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 the tool's function: 'Get a model recommendation for a task type without running inference.' It specifies the resource (model recommendation) and the action (get), and differentiates from inference-related siblings like compute.route by emphasizing 'without running inference.'

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

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

Explicit use cases are provided: 'Use this when an agent needs to select a model before committing to inference, or to surface model selection logic to a human.' This implies the tool is not for actually running inference, but it does not explicitly name sibling alternatives or state 'when not to use' beyond the purpose phrasing.

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 context beyond annotations: 'All models are free-tier (no token cost) — routed via OpenRouter.' and 'Returns model IDs, provider, capability strengths, context window, and speed tier.' This informs the agent of cost and routing behavior not captured in 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 concise sentences. The lead sentence states the purpose, the second provides key behavioral facts (free, OpenRouter, return fields), and the third gives usage guidance. No filler or redundancy; every sentence earns its place.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is complete: it covers what the tool does, what it returns, cost implications, and how to use it in the broader compute workflow. No essential 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, and the schema is empty with 100% coverage (trivially). The baseline for zero parameters is 4. The description does not need to explain parameters, and it adds no misleading parameter information.

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

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

The description opens with a specific verb and resource: 'List all AI models available through DPX Compute.' It also enumerates the return fields (model IDs, provider, capability strengths, context window, speed tier) and explicitly differentiates from compute.route by saying 'Use this before 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 gives explicit guidance: 'Use this before compute.route to understand what models are available and pick the right one for a task.' This clearly states when to use the tool relative to a sibling, fulfilling the when-to-use requirement and indicating its purpose in the 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?

The description discloses key behavioral traits beyond the annotations: model selection logic (reasoning → DeepSeek R1, code → Llama 3.3 70B, etc.), free-tier pricing with no token cost, payment via x402 in USDC, and integration with OpenRouter. These details give the agent a clear model of side effects and costs, which the annotations (only openWorldHint=true) do not 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 concise: four sentences, each adding distinctive value. It starts with the primary action, then details the routing logic, cost model, and a clear use-case sentence. There is no filler or repetition of schema 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 moderate complexity and lack of an output schema, the description covers the essential operational context: what the tool does, how models are chosen, cost (free-tier plus x402 payment), and what it returns ('returns the completion'). It is sufficiently complete for an agent to select and invoke the tool.

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

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

The input schema has 100% coverage for the 3 parameters, each with a description. The tool description adds examples of model selection but does not add new meaning to the parameters beyond the schema. Per the rubric, baseline 3 is appropriate when schema coverage is high.

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

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

The description opens with a specific verb-resource pair: 'Route a task to the best available free AI model and run inference.' This clearly identifies the tool's function and scope. It also distinguishes itself from sibling tools like compute.cost and compute.models by focusing on executing inference rather than just listing models or costs.

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 includes an explicit recommendation: 'Use this when an agent needs to delegate a subtask to a language model without managing model selection or API keys.' This clearly states when to use the tool. However, it does not mention when not to use it or offer alternative 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 provide destructiveHint=true and readOnlyHint=false, so the description doesn't need to re-state mutation. It adds value by outlining the internal flow ('oracle gate → compliance screen → settlement flow') and stating it returns a receipt. This goes beyond what annotations capture, giving the agent a sense of the process. 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?

Four sentences, front-loaded with the core purpose. Every sentence earns its place: what it does, when to use, what happens in the backend, and an alternative for a specific case. No redundancy or fluff.

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

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

Given the tool's complexity (payment with compliance, multiple siblings, output schema exists), the description covers purpose, usage context, internal flow, return value, and an alternative tool. It is self-contained and provides enough information for an agent to invoke it correctly without needing additional context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add new meaning for individual parameters beyond what the schema already provides. It mentions 'describe what you see, provide amount and recipient' but that is already covered by the parameter descriptions. The note about settlement.nl for bank/email is a usage guideline, not parameter 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 completes a payment identified by Claude's computer use session, with specific examples like checkout forms and wire transfer UIs. It distinguishes from siblings by explicitly naming settlement.nl as an alternative for bank/email cases and positioning this tool as the replacement for typing credentials.

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

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

Explicit guidance: 'Call this instead of typing credentials into a UI' and 'Use whenever computer use encounters a payment that would otherwise require human re-entry or approval.' It also provides a clear exclusion: if only bank/email is visible, use settlement.nl instead. This helps the agent decide when to invoke this tool versus alternatives.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that data comes 'directly from production telemetry' and notes it's 'free' and requires 'no auth,' providing valuable context beyond 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 three sentences, each serving a purpose: defining the tool, listing outputs, and stating usage context. It is front-loaded and efficient, though the second sentence could be slightly tighter.

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 only one simple parameter, output schema present, and annotations covering safety, the description is fully complete. It explains the data source, content, and usage context, leaving no obvious gaps for agent invocation.

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

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

Schema coverage is 100% with a well-described parameter (window). The description doesn't rehash the parameter but adds context about the metric types returned, which complements the schema. The single parameter is clearly 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 returns live performance metrics for DPX settlement infrastructure, listing specific data types (request volumes, error rates, etc.). It distinguishes by targeting investor due diligence and portfolio management use cases, though it doesn't explicitly differentiate from any specific sibling tool.

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

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

The description mentions it's free and requires no auth, but provides no guidance on when to use this tool versus alternatives like settlement.status or analytics.overview. Use context is implied (investor queries, due diligence), but no exclusions or comparisons to siblings are given.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, making safety profile clear. Description adds valuable behavioral details: batch size ceiling of 50, GLEIF resolution for names, ranking by composite ESG score, and a latency nuance for name-based queries. 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?

Four sentences, each earning its place: capacity & input types, output behavior, use cases, performance caveat. Front-loaded with the core action. No redundancy or fluff.

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 input schema and output schema exist (schema coverage 100%, output schema present), the description fully completes the picture by covering capacity, input options, ranking behavior, use cases, and performance nuance. No gaps remaining.

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 baseline is 3. The description adds value by clarifying that LEIs are the 'fastest path' and that names go through slower GLEIF resolution ('≤3s per name'), enhancing parameter understanding beyond schema alone.

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

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

Clearly states a specific verb ('Screen') and resource ('entities'), specifies batch size limit (50), input types (LEIs or company names), and output behavior (ranked by ESG score descending). Distinguishes from siblings like esg.lookup by focusing on batch screening vs single entity.

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, and TMS pre-payment checks'. Notes performance trade-off ('Name resolution is slower than direct LEI input'). Lacks explicit when-not-to-use or alternative tool names, though some are implicitly evident from sibling context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds significant context: it uses GLEIF for resolution, returns specific pillar scores, a composite, fee surcharge tier, and a per-source breakdown. It also mentions the AI synthesis layer for the narrate parameter. 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 paragraph of four sentences, front-loading the main action. It is concise with no fluff, though it could be more structured (e.g., bullet points) for readability. Every sentence serves a purpose.

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

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

Given the tool has 3 parameters (all described), an output schema, and annotations covering safety, the description adequately explains the output structure and usage context. It covers the main purpose, input types, and output components. Minor gaps: the fee surcharge tier and sources are mentioned but not detailed, likely covered by 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 the baseline is 3. The description adds some context (e.g., resolution via GLEIF, removal of LEI requirement) but does not elaborate on parameter syntax or format beyond what the schema provides. It meets the baseline but does not exceed it significantly.

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 resolves a company name/domain/ticker to a LEI and returns full ESG scores. It distinguishes from siblings like esg.score by explicitly stating it removes the need for a LEI, and provides a specific use case ('Use when you have a company name but not a LEI').

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 when you have a company name but not a LEI'). It implies when not to use (if you have a LEI, use another tool) but does not explicitly name alternatives. The return structure is described, aiding tool selection.

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

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

Annotations already declare readOnlyHint=true, so the description correctly implies a read operation. The description adds valuable behavioral context: a 200-entity limit, LEI vs. name resolution, and the portfolio-level composite nature. No contradiction with annotations. The description goes beyond the annotations by explaining the scope and limits of the operation.

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

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

The description is three sentences, each serving a clear purpose: first sentence states the action and limit, second lists outputs, third gives canonical usage. No wasted words, front-loaded with the key verb and scope. 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?

Given the tool has 3 optional parameters, a read-only annotation, and an output schema (not shown but exists), the description covers purpose, constraints (200 entities), and usage context (pre-settlement compliance). The list of return values is sufficient for an agent to understand what to expect. No gaps remain for the intended use case.

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 helpful descriptions for each parameter (e.g., 'LEIs to score (fastest — no name resolution)'). The tool description adds the constraint of 'up to 200 entities' and the portfolio-level context, which is not in the schema. This adds meaning beyond the schema, raising the score from baseline 3 to 4.

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 scores an entire counterparty portfolio up to 200 entities by LEI or name. It lists specific return values (composite scores, tier distribution, fee surcharge impact, etc.). The sibling tools include esg.lookup, esg.score, esg.batch, esg.trend, and esg.watch, and this description distinguishes itself by being a portfolio-level aggregate call, not a single-entity or trending tool.

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

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

The description explicitly says 'The canonical pre-settlement compliance check for treasury systems and TMS integrations,' which provides clear context for when to use this tool. It also implies a portfolio need (vs. single entity). However, it does not explicitly state when not to use it or name alternative sibling tools for single-entity or trend analysis, so some guidance is missing.

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. The description adds valuable behavioral context: data is live and updated hourly from six institutional sources. This goes beyond what annotations provide, though it does not mention rate limits or error behavior.

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

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

The description is a single compact paragraph of five sentences. It front-loads the core purpose, then efficiently lists return fields, data sources, and regulatory context. 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?

Given the tool's simplicity (one optional param, output schema exists, rich annotations), the description covers all essential aspects: purpose, output composition, update frequency, data sources, and regulatory use cases. It is fully adequate for an agent to understand 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?

Schema coverage is 100% with a clear description of the 'address' parameter. The description slightly reinforces the protocol default behavior but does not add new semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns a live ESG counterparty risk score for a wallet address or protocol default, listing specific output fields (E, S, G scores, composite, settlement fee). It distinguishes from siblings by focusing on single-entity live scoring, contrasting with batch or portfolio 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 indicates when to use (for a single address or default, and for EU SFDR/CSRD reporting) but does not explicitly contrast with related sibling tools like esg.batch or esg.lookup. It lacks guidance on when not 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 already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds beyond this by explaining that data accumulates each time the entity is scored via other ESG tools (esg.lookup, esg.batch, esg.portfolio) – a behavioral detail not captured in annotations. It also clarifies the output includes trend direction and delta. 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 two sentences with no wasted words. The first sentence states purpose and what is returned. The second sentence adds usage context and a behavioral note. Information is front-loaded and every sentence earns its place.

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

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

Given the tool's low complexity (2 parameters, no enums, no nested objects) and the presence of an output schema (so return values are documented externally), the description covers all essential aspects: what the tool does, how data is generated, use cases, and constraints (lookback window). An agent has sufficient context 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?

Schema description coverage is 100%, with both parameters already well-documented ('20-character GLEIF LEI.' and 'Lookback window in days (7–365). Default 90.'). The description mentions 'by LEI' and 'over the requested window' but does not add meaningful new details beyond the schema. Baseline 3 is appropriate given 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 opens with a clear verb+resource: 'Get the historical ESG composite trend for a specific entity by LEI.' It then details the returned data (score history, trend direction, delta) and explicitly distinguishes itself from sibling tools (esg.lookup, esg.batch, esg.portfolio) by explaining how data accumulates from those scoring actions. This differentiates the tool effectively.

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 specific use cases: 'due diligence, MiCA Article 72 ongoing monitoring reports, and detecting counterparties whose ESG posture is degrading.' This gives clear context for when to use the tool. It lacks explicit when-not-to-use guidance or mention of alternatives, but the implicit differentiation from point-in-time tools (esg.score) and the focus on historical trend is sufficient for an agent to make a reasonable choice.

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

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

Annotations provide readOnlyHint=false and destructiveHint=false, already indicating a mutation with no destruction. The description adds significant behavioral context: daily frequency, threshold-based webhook triggering, webhook payload contents (previous/current score, delta, tier change), and the return of a watchId. This goes well 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 composed of five sentences, each serving a distinct purpose: purpose, mechanism, regulatory context, return value, and payload details. While slightly verbose, every sentence adds value, and there is no filler. Front-loading is adequate.

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 complexity (3 params, output schema exists per context signals, annotations present), the description covers core aspects: purpose, trigger conditions, frequency, return value, and payload structure. It omits webhook retry behavior, cancellation method, and concurrency limits, but these are secondary given the output schema likely handles response 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?

Schema description coverage is 100%; all three parameters (lei, webhookUrl, thresholdPoints) are documented in the schema. The description does not add new meaning to these parameters beyond referencing thresholdPoints in the webhook condition. It meets the baseline but provides no extra value for 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 uses a specific verb-resource pair: 'Register an entity for ongoing ESG monitoring.' It clearly distinguishes this from sibling tools like esg.score (one-time score), esg.trend (historical trend), and esg.batch (batch operations) by emphasizing 'ongoing' and webhook-based alerts.

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 continuous monitoring needs (daily checks, webhook on threshold) but does not explicitly state when to use this tool versus alternatives like esg.score or esg.portfolio. No exclusions or prerequisite conditions are given, so it's clear but not comprehensive.

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 declare readOnlyHint=true, destructiveHint=false, and idempotentHint=false, which the description does not contradict. The description adds behavioral context: it returns dollar savings and compliance statuses. No detail on data freshness or rate assumptions, but the core of what it does and does not modify is clear.

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, information-dense: enumerates competitors, states what is returned (savings, compliance). No wasted words. Front-loaded effectively.

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, the description does not need to describe return values in detail. It covers the key input parameter's usage, lists competitors, and mentions compliance outputs. Fully adequate for a well-structured tool with rich schema and annotations.

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 baseline is 3. The description adds meaning beyond the schema by explaining that 'hasFx' incurs an 'adds 0.40% FX fee,' which is not in the parameter description. This provides useful context for how the parameter affects the comparison logic.

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?

Describes a specific verb (compare) on a specific resource (DPX settlement cost) against an enumerated set of competitors. Clearly distinguishes from siblings like 'fees.schedule' (likely a schedule, not a comparison) or 'fees.verify' (verification, not comparison).

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 that the tool compares costs and returns savings and compliance status. However, does not explicitly state when NOT to use it or mention alternatives among siblings—though the sibling set is large, and no direct alternatives for fee comparison are obvious.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds significant behavioral context by detailing the scope of the return value—components, tiers, ESG table, examples, and benchmarks—which goes beyond what the annotations convey. This helps an agent understand the richness and purpose of the output.

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

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

The description is a single, front-loaded sentence that efficiently lists all key elements of the schedule. While it packs a lot of information, it remains readable and free of fluff. The structure could be improved by using bullet points or breaking into shorter sentences, but it is still concise and 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?

Given that the tool has zero parameters and an output schema exists (reducing the need to explain return values), the description thoroughly covers what the tool returns: components, tiers, ESG table, scenario examples, and competitive benchmarks. This is complete for a read-only schedule retrieval 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 input schema has zero parameters, and schema coverage is 100% (all params covered). The rubric sets a baseline of 4 for tools with no parameters. The description does not need to discuss parameters, but it adds value by describing the content of the output, which indirectly clarifies what the tool returns without input.

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 'Get' and names a specific resource 'complete DPX fee schedule'. It enumerates the components (core/FX/ESG/license), volume discount tiers, ESG fee table, scenario examples, and competitive benchmarks. This level of detail distinguishes it from sibling tools like fees.compare (which would compare schedules) and fees.verify (which would verify specific fees).

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 states the tool's purpose—retrieving the full fee schedule—but does not provide explicit guidance on when to use this tool versus alternatives. It does not mention sibling tools (e.g., fees.compare, fees.verify) or conditions under which the tool should or should not be used. Contextual cues from the tool's name and content imply uses, but no direct or comparative guidance is given.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by explaining the return value (feesMatch boolean) and the verification context, which aligns with the non-destructive read operation. No contradictions; the description complements the annotations 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?

Two sentences: first sentence states the purpose, second sentence states the return value and workflow order. Every sentence earns its place; no fluff. Front-loaded with the core action. 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?

The description covers the purpose, return value, and workflow placement. An output schema exists, so return value details are complete. The explanation of how parameters affect verification is left to the schema, which is acceptable. Slight gap: it doesn't mention that the tool is safe to call multiple times, but the idempotentHint annotation covers that. Overall, sufficient 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 description coverage is 100%, so the baseline is 3. The description does not add additional meaning beyond the schema's parameter descriptions (hasFx, esgScore, amountUsd). It implies these are inputs for fee verification, but no extra semantic detail is provided. The schema already explains each parameter adequately.

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

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

Clearly states the tool's purpose: verify that an off-chain fee quote matches the on-chain DPXSettlementRouter charge. It specifies the verb 'verify', the resource (fee quote vs on-chain), and the return value (feesMatch boolean). The workflow context 'after get_quote and before settle' distinguishes it from sibling fee tools like fees.compare and fees.schedule, which serve different purposes.

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

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

The description explicitly recommends calling this tool after get_quote and before settle, providing clear positioning in a workflow. It does not directly contrast with alternatives (e.g., fees.compare or fees.schedule), but the workflow guidance is sufficient for an agent to decide when to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description carries a lower burden. It adds value by revealing the parallel execution nature, the unified output structure, and the return of a 'ready-to-use settleBody', which goes beyond the annotations. 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?

The description is concise at 3-4 sentences, front-loaded with the core purpose ('Single pre-flight call before settling'), and efficiently covers the alternatives replaced and the key return fields. Every sentence serves a clear function with no 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 is fairly complex (5 parameters, combined checks, output fields), and the description covers the main purpose, replacement logic, and return structure. It lacks details on defaults (though schema hints at USD), error handling, or idempotency behavior (annotations say not idempotent). However, with output schema present, the listed return fields suffice for basic understanding.

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 descriptions for all 5 parameters, so the baseline is 3. The description adds no parameter-specific information beyond what the schema already provides, treating the parameters holistically. It does not improve or extend the schema's explanations.

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 as a single pre-flight call that combines oracle check, compliance screen, and stablecoin routing into a unified go/no-go decision. It explicitly contrasts with the alternative 3-step loop, distinguishing it from sibling tools like compliance.pep_screen and oracle.stability.

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 context for when to use this tool: before settling, as a replacement for the multi-step oracle → screen → route loop. However, it does not specify scenarios where using the individual steps might be preferred (e.g., for granular control or debugging), missing 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 readOnlyHint, idempotentHint, destructiveHint=false, so the non-mutating, safe nature is clear. The description adds significant context: returns 12 sorted events with commodity impact details, severity, and agronomic basis, which enriches the behavioral understanding beyond just 'read-only.' No contradiction with annotations.

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

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

The description is two sentences with zero waste. The first sentence immediately establishes the core purpose (seasonal climate calendar with commodity impact). The second efficiently details the 12-window scope, sorting logic, and output fields. Every sentence is necessary 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?

Given zero parameters, an output schema existing, and clear annotations, the description needs only to clarify what the tool returns and how it's organized. It fully covers the purpose, sorting logic, content (affected commodities, severity, agronomic basis), and scope (12 annual windows). No gaps remain for a read-only, no-param 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 input schema has zero parameters and 100% coverage, so there is nothing to describe beyond what the schema provides. The description adds value by clarifying what the output contains (12 windows, sorted, with commodities/severity/agronomic basis) but does not need to explain parameters.

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

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

The description clearly states it returns a 'seasonal climate event calendar with commodity impact,' specifying the resource (calendar) and the verb (returns). It distinguishes itself from siblings like forecast.commodity_outlook by focusing on a pre-defined set of 12 annual windows, not broad commodity predictions.

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 use for understanding seasonal climate risks and their commodity impact, but lacks explicit guidance on when to use this versus other forecast tools (e.g., forecast.scenario for custom scenarios, forecast.commodity_outlook for commodity-specific trends). No 'when-not-to-use' or alternative strategies are mentioned.

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 this as read-only (readOnlyHint=true) and non-destructive. The description adds valuable behavioral context: the 4-hour cache, the ability to bypass it with the 'fresh' parameter, the specific return structure (signal, horizons, confidence, region breakdown, FRED price), and a disclaimer. This enriches the agent's understanding beyond what annotations provide. Score 4.

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 tightly written, with each sentence adding information. The first sentence states the core purpose ('Climate-driven price pressure outlook for a commodity'). The structure is clear and easy to parse. There is no wasted text or repetition. Score 5.

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

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

The tool has a moderately complex output (multiple horizons, confidence, region breakdown, price reference), but an output schema exists. The description provides a high-level summary of the return structure, lists all supported commodities, mentions cache, and includes a disclaimer. It is adequate for an agent to understand what the tool returns and when to use it. Minor omissions: no mention of error handling or rate limits, but these are not critical for a read-only tool. Score 4.

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 base is 3. The description does not add additional meaning to the parameters beyond what the schema already provides. The 'fresh' parameter's cache-bypass behavior is explained in the schema, and the description's mention of 'Cache: 4h' is redundant. The symbol enum is fully listed. Thus no extra value is added. Score 3.

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

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

The description clearly states the tool's function: 'Climate-driven price pressure outlook for a commodity.' It specifies the exact output format (BULLISH/BEARISH/NEUTRAL signals with horizons, confidence, region breakdown, FRED price) and lists the 11 supported commodities. However, it does not explicitly differentiate from sibling forecast tools (e.g., forecast.calendar, forecast.scenario), so a score of 4 is appropriate.

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 mentions the target audience ('institutional research teams evaluating commodity positions') and clarifies that signals reflect supply constraint risk, not a financial recommendation. But it does not provide explicit guidance on when to use this tool versus other forecast tools, nor does it state when not to use it (e.g., if a user needs financial advice or non-climate factors). This leaves room for ambiguity. Score 3.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating safe operation. The description adds behavioral details: weights are normalized internally (revealing stateless transformation), returns aggregate score, stressed positions, hedges, and plain-language summary. With annotations providing safety info, description compensates well with richer behavioral 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 three concise sentences with no waste. First sentence states core function, second explains parameters and returns, third gives concrete use case — front-loaded with essential information.

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

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

Given the tool has one parameter with 100% schema coverage, an output schema (not shown to me but present per context signals), and no nested objects, the description sufficiently covers input requirements, return value categories, and target audience. No gaps remain for an agent to misuse 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 coverage is 100%, so baseline is 3. The description adds value by clarifying that weights can be percentages or fractions (flexible formats), that they are normalized internally, and that up to 20 positions are allowed — supplementing the schema's 'maxItems' constraint and abstract weight 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 performs a 'climate stress test' for a 'multi-commodity portfolio', using a specific verb ('stress test') and resource ('portfolio'), with explicit constraints (up to 20 positions, normalized weights). It distinguishes from sibling tools like 'forecast.commodity_outlook' or 'forecast.scenario' by focusing on portfolio-level stress testing with climate scoring and hedging insights.

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 calls out a specific use case ('useful for commodity fund managers evaluating aggregate climate exposure before rebalancing'), which helps decide when to use it. However, it does not explicitly say when not to use this tool or name alternative tools for different scenarios (e.g., single-commodity stress testing could use forecast.scenario).

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the description doesn't need to repeat these. The description does not contradict any annotations. The description adds valuable context about the output (ranked list, risk levels, commodity links), but since it takes no parameters (0 params), there's little to disclose about behavioral traits beyond what annotations cover.

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 focused two-sentence block. The first sentence succinctly describes the data (40 regions, ranked by risk), and the second sentence provides use-case guidance. Every sentence serves a purpose. It's not overly verbose, but could be slightly more front-loaded by placing the use-case first.

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

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

Given the tool has zero parameters, annotations that fully cover its behavioral traits (read-only, idempotent), and an output schema (assumed present if not detailed), the description is complete. It tells the agent what the tool returns (ranked list with risk levels and commodities), and why to use it (identify climate stress and commodity exposure). There's no missing context for correct tool selection and invocation.

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

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

With 0 parameters and 100% schema coverage, the description adds no parameter-specific details for completeness. However, the description compensates by clearly explaining what the output contains (regions ranked by risk, with commodities and risk levels, which implicitly tells the agent what to expect. For a parameterless tool, the score defaults to 4--the description effectively communicates output semantics beyond just the schema's void object.

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 provides a ranked list of ~40 global commodity production regions with climate risk scores and commodity exposure. It uses specific verbs ('ranked by,' 'shows,' 'identify') and the resource is well-defined as production regions with their risk levels and affected commodities. It also distinguishes from siblings like forecast.commodity_outlook (which focuses on commodities rather than regions) and forecast.portfolio_stress (portfolio-level 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?

The description explicitly states the tool's purpose: to identify geographic zones under climate stress and which commodities are most exposed. This implies it should be used for climate risk analysis on production regions, not for commodity-specific or portfolio-specific forecasts. However, it doesn't explicitly mention when NOT to use it or name alternative sibling tools for related purposes, which would improve clarity further.

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 (no mutation) and destructiveHint=false, so the description's job is lighter. The description adds valuable context: that built-in scenarios exist, how to combine symbols, and that omitted symbols analyze all 11 commodities. It doesn't describe the output format, but output schema exists to handle that. Minor gap: doesn't state that scenarios and stressorOverrides are mutually exclusive, though implied.

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 with zero waste: first states core function, second enumerates scenarios, third gives usage context. Front-loaded with the most important info. Every sentence earns its place.

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

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

Given low complexity (3 params, none required), complete schema coverage, and presence of output schema, the description fully covers what an agent needs: purpose, inputs, available scenarios, and usage advice. No gaps remain.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by explaining the purpose of the tool (stress-testing), which helps interpret the symbols and scenario parameters in context. It also lists built-in scenarios, which overlaps with schema enums but reinforces usability. The stressorOverrides concept of multipliers (1.0 = no change) is clarified.

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 ('Apply') and resource ('named scenario or custom stressor multipliers to any subset of commodities'), and explicitly distinguishes from siblings like forecast.commodity_outlook and forecast.portfolio_stress by focusing on what-if scenario stress-testing for specific commodities.

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 when-to-use guidance ('Use to stress-test a commodity thesis before committing to a position') and distinguishes between built-in scenarios and custom stressorOverrides. It also implies when-not-to-use by focusing on commodities, separating it from portfolio-level tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, so the agent knows it's safe. The description adds context about the data returned (stability tier, volatility, regulatory flags) and sort order, but does not reveal additional behavioral traits 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?

Three sentences, each earning its place: first states what the tool returns, second explains sort order, third gives usage guidance and filter instruction. No wasted words, well 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 simple interface (one optional param, output schema exists), the description covers all necessary information: what data is returned, sort order, filtering, and a concrete use case. It is fully sufficient for an agent to decide when to call 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 already describes the single optional parameter 'from' with a clear example. Description reiterates this ('Filter by source currency with the from parameter') but adds no new semantic information. With 100% schema coverage, 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?

Description clearly states it lists all 60+ currency corridors with stability tier, volatility, and regulatory flags. It distinguishes from siblings like stability.corridor or fx.rate by positioning itself as a broad comparison tool for choosing payment routes, with an example query.

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

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

Explicitly says 'Use to compare corridors before choosing a payment route' and provides a concrete example. It explains filtering by source currency. However, it does not explicitly mention when not to use this tool or name alternatives, leaving some room for ambiguity.

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 declare readOnlyHint=true and destructiveHint=false, so the tool is a safe, read-only query. The description reinforces this as a quote lookup but adds behavioral traits: the output is CFO-grade with specific components (exact amount, 48h variance in dollars, corridor stability, optimal window). Also discloses the x402 micropayment, which annotations do not cover.

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 pack essential market position, usage scenario, and cost requirement with zero fluff. Front-loaded with the main action ('All-in settlement cost quote for cross-border payments') immediately.

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 5 parameters, 100% schema coverage, annotations, and an output schema, the baseline is high. The description completes the picture by stating the output components (exact amount, variance, corridor, window) and the payment requirement. However, it does not mention whether the quote expires or how to use the output schema for further actions.

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% (all 5 parameters documented). The description adds value beyond schema by explaining the purpose of the output parameters (variance in dollars, corridor stability overlay), but it does not add new meaning to individual input parameters like 'lei' for ESG-adjusted fee tier 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 uses specific verbs ('cost quote for cross-border payments') and clearly names the resource ('all-in settlement cost' for FX). It differentiates from siblings like 'fx.rate' (simple rate lookup) and 'stability.settlement_window' (timing vs cost) by emphasizing 'cost certainty' and net settlement amount.

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 hints at when to use this tool by answering 'if I send $X today, what does my counterparty receive net of everything?' and includes key context: requires a micropayment (x402). However, it does not explicitly state when NOT to use it (e.g., for simple rate checks use fx.rate).

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 read-only, idempotent, non-destructive behavior. The description adds valuable context: source (central bank rates via open.er-api.com), update frequency (hourly), no API key required, and 'free'. This goes 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?

Two sentences with no wasted text. The main purpose is front-loaded, and every sentence adds value. 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 an output schema, the description covers purpose, return fields, data source, update frequency, and access requirements. It is complete and leaves no major gaps.

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

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

Schema coverage is 100% with both from and to described as ISO 4217 codes. The description does not add additional meaning 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 provides a 'live mid-market FX rate for any currency pair' and lists specific return fields. This distinguishes it from sibling tools like fx.corridors and market.fx by specifying exactly what it does.

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

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

The description implies usage for fetching a live FX rate but does not explicitly guide when to use this tool versus alternatives like fx.corridors or market.fx. No 'when not to use' or comparative guidance is provided.

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

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

Discloses full behavioral details beyond annotations: polls Base mainnet, returns 'pending' until payment detected, then 'verified' with txHash and Basescan link. Also specifies the polling interval. No contradictions with annotations (readOnlyHint, idempotentHint, destructiveHint).

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, no wasted words. Front-loaded with purpose. Every sentence adds value. Perfectly concise for the information conveyed.

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

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

With a single parameter, an output schema present, and complete description of return values and polling behavior, the description leaves no gaps for an agent to misuse the tool. Fully sufficient given the tool's complexity.

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

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

Schema description coverage is 100%, and the parameter 'id' is described as 'verificationId returned by integration.verify.' The description does not add extra meaning beyond the schema, 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?

Clearly states the tool checks the status of a DPX integration verification session. Uses a specific verb ('Check') and resource. Does not explicitly differentiate from the sibling integration.verify, but the context implies it is the follow-up status check.

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

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

Provides explicit polling guidance ('Poll every 10–15 seconds after sending the payment'), which tells the agent when to use this tool. Does not list when not to use it or alternatives, but the guidance is clear and actionable.

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

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

The description reveals that the tool initiates a USDC payment handshake and returns treasury address and payment instructions, which is useful beyond annotations. However, it does not clarify idempotency or behavior on repeated calls, leaving some behavioral gaps.

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 at 4 sentences, front-loaded with purpose, and every sentence adds value without redundancy. Excellent structure.

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

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

Given the simple tool with 2 parameters and an output schema, the description fully covers the purpose, flow, return value, and next steps. No additional information is 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 coverage is 100% with both parameters already described. The description adds a small detail about apiKey being hashed but doesn't significantly enhance understanding beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Initiate' and the resource 'onboarding handshake for a new DPX integration.' It distinguishes from the sibling tool integration.status by mentioning polling for confirmation.

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 'Required for all new integrations before production settlements are enabled' and advises to call integration.status to poll for confirmation. It provides clear context for when to use the tool, though it doesn't explicitly exclude other 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 declare readOnlyHint=true and destructiveHint=false, but description goes far beyond: details three specific waves with time windows, identifies what analysis is returned (rebounding nodes, amplified pressure, structural changes), and explains it is a POST operation. No annotation contradiction. Full behavioral disclosure for a modeling 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 a single dense paragraph of ~100 words covering purpose, output, usage, and parameters. It is front-loaded with the tool's purpose. Slightly verbose with the wave details but every sentence earns its place. Could be split into two sentences for clarity without losing 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 complexity (5 parameters, output schema present, rich annotations), the description is complete. Output schema handles return value documentation, so the description need not explain output format. It covers prerequisite, input context, behavioral traits, and parameter semantics thoroughly.

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%, but description adds significant value by explaining how parameters map to the cascade model context. 'origin' is contextualized as 'from the primary cascade', 'magnitude' is placed in scale 1–100, and default values are given for elapsedHours and horizonHours. Description also reveals horizonHours exists (not shown in param list but implied by '4320 (6 months)').

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 models aftershock waves from a primary cascade event, with specific verb 'models' and resource 'secondary waves'. It distinguishes itself from sibling 'intelligence.*' tools like intelligence.contagion, intelligence.tectonic, and market.cascade, explicitly noting it runs after market.cascade.

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

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

Explicitly states when to use: 'run cascade first, then aftershock to see the full picture.' Names companion tool market.cascade as prerequisite, providing clear workflow guidance. Implies not for first-order event modeling.

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 (readOnlyHint=true, idempotentHint=true, destructiveHint=false) already convey it's a safe, read-only, idempotent operation. The description adds value beyond annotations by explaining the R-value model, the 6 domains, and the specific output components (system R trajectory, spread map, superspreader nodes, containment forecast, AI briefing). 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 approximately 80 words across 4 sentences, front-loading the purpose and model. Every sentence adds value except the last two ('Call /contagion/nodes...' and 'POST with origin...') which are critical usage guidance but could potentially be more concise if merged. Still well-structured and 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 the tool has an output schema (alleviating need to describe return format), 3 parameters with 100% schema coverage, and strong annotations, the description is nearly complete. It explains the core model, usage flow, and parameter behavior. Minor gap: it doesn't explain what the 'AI briefing' output contains, but with an output schema this is acceptable.

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 baseline is 3. The description adds value by explicitly mentioning 'origin' parameter context (call /contagion/nodes first), explaining that listNodes bypasses simulation, and giving magnitude range 1–100. This goes beyond the schema's basic descriptions, justifying a 4.

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 simulates how a macro or financial shock spreads using an epidemiological R-value model, specifying the 30 nodes across 6 domains. It distinguishes itself from siblings like intelligence.tectonic (which likely models different phenomena) by detailing the unique R-value modeling approach and the specific output components (system R trajectory, spread map, etc.).

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 guidance to call /contagion/nodes first to discover valid origin IDs, and explains how to use listNodes:true for discovery. It interprets the R-value threshold (R < 1.0 = self-limiting; R ≥ 1.0 = expanding). However, it does not explicitly state when not to use this tool versus siblings like intelligence.resonance or intelligence.aftershock, or what distinguishes contagion from those.

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, so the description adds value by detailing the computation logic (GBV → female LFPR suppression → GDP drag → fiscal stress → sovereign risk premium), data sources (WHO GHO, World Bank WDI, FRED), 12h cache, and live FRED feedback. This goes beyond simple safety 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 information-dense but well-structured, leading with purpose, then explaining the two scores, then providing operational details like data sources and cache. Each clause adds value, although it is longer than typical. The front-loading of purpose is effective.

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 no-input GET tool with an output schema, the description covers the key context: what the scores mean, the underlying transmission mechanisms, data sources, caching behavior, and the fact that no input is required. It is sufficient for an agent to understand the tool's functionality and behavior.

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

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

The schema has zero parameters, and the description explicitly states 'No input required — GET,' making it clear that no inputs are necessary. This adds an operational detail beyond the empty schema and meets the baseline for zero-parameter 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 clearly states the tool's purpose: it maps the structural relationship between GBV prevalence, legal discrimination, female labour force participation, and economic outcomes across 18 countries, and returns two scores. The verb 'maps' and the specific resource 'Gender Risk & Opportunity Intelligence' clearly distinguish it from sibling intelligence tools like aftershock, contagion, etc.

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 gender risk and opportunity analysis, but it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or alternative tools. The phrase 'No input required — GET' is an operational detail, not a usage 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?

Annotations already provide readOnlyHint, idempotentHint, etc. The description adds value by explaining the concept of resonance, the return data, and that no input is required. It is consistent with annotations and adds behavioral context beyond 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 four sentences, all relevant. It front-loads the definition and then provides implications and return details. Could be slightly more concise, but no waste.

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

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

Given no parameters, rich annotations, and an output schema, the description is complete. It explains the tool's purpose, what it returns (including specific outputs like phase angles and resonance clusters), and its read-only nature.

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

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

There are no parameters, so the schema coverage is 100%. The description explicitly states 'No input required — GET', which is sufficient. Baseline for 0 params is 4, and the description adds no further parameter meaning but confirms the absence.

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 detects resonance among macro forces, with specific verb 'detects' and resource 'Resonance Intelligence'. It distinguishes from siblings like intelligence.aftershock and intelligence.contagion by focusing on phase oscillation across 28 signals in 5 domains.

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 it's a read-only diagnostic tool but does not explicitly state when to use it versus alternatives or provide exclusions. The sibling tools are not compared, so guidance is implied rather than explicit.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, but the description adds valuable behavioral details: the cron checks hourly, it's edge-triggered (not repeated), and returns a subscriptionId. This disclosure of polling frequency and triggering semantics goes beyond what annotations provide, though it could mention that the webhook URL receives POST requests and any error handling or retry 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 at three sentences, each serving a distinct purpose: first explains the action and supported signals, second details trigger behavior, third lists use cases. No redundant information; every sentence is necessary and front-loads the core purpose.

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

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

Given the tool's complexity (5 parameters, 2 enums, output schema exists), the description covers the main purpose, supported signals, trigger behavior, and use cases. It does not explain the output schema's contents (likely includes subscriptionId), but since an output schema exists, that burden is reduced. It could improve by mentioning that the webhook must be HTTPS and that the tool creates a persistent subscription.

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 value by explaining the supported signals in detail (overall 0–100 score, shock propagation risk) and the meaning of 'above'/'below' direction with a default. However, the description does not explicitly clarify that threshold is 0–100, which is already in the schema. The 'any' signal option is explained, adding context beyond schema enums.

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 registers a webhook for threshold-based alerts on DPX intelligence signals. It lists the supported signals explicitly and distinguishes itself by specifying the type of intelligence subscription (threshold-based webhook) versus other sibling tools like intelligence.subscription.get or intelligence.subscription.delete.

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 guidance on when to use this tool: for treasury alert systems, TMS integrations, or autonomous agent monitoring loops. It clearly distinguishes from siblings by implying the return of a subscriptionId for status checks and cancellation, which relates to intelligence.subscription.get and intelligence.subscription.delete. It does not explicitly state when not to use it, but the context of alerts and the sibling names make alternatives 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?

The description explicitly states 'Stops future webhook alerts', 'The alert log is retained for audit purposes', which provides critical behavioral context beyond the annotations. The annotations already declare destructiveHint=true and idempotentHint=true, but the description explains exactly what is destroyed (future alerts) and what is preserved (log), adding transparency and managing expectations.

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 concise, front-loaded sentences. Each sentence delivers distinct and essential information: what it does, what it stops, and what it retains. 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?

Given the low complexity (1 param, clear schema, good annotations), the description is adequately complete. An output schema exists, so return values need no explanation. A slightly higher score would require mentioning prerequisites (e.g., valid subscription ID) or error conditions.

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 only one parameter 'subscriptionId' described as 'UUID returned by intelligence.subscribe.' The description doesn't repeat the schema, but it implies the parameter is a unique identifier. A higher score would require adding context like 'Use the subscriptionId from the subscribe response' directly in the description, but the schema already provides a clear 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 uses a specific verb ('Cancel') and resource ('intelligence subscription by ID'), immediately and precisely conveying what the tool does. It also distinguishes clearly from the sibling 'intelligence.subscription.get' (which retrieves) and 'intelligence.subscribe' (which creates), 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 states 'Stops future webhook alerts for that subscription', clarifying the effect of use. It does not explicitly specify when NOT to use it (e.g., if alerts are still needed) or name an alternative tool for modifying subscriptions, but given the one-purpose tool design and sibling list, the implication 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 already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, which cover safety and idempotency. The description adds modest behavioral context by listing return fields ('signal score, last fired timestamp, total alerts fired, and subscription configuration'), but these are also documented in the output schema. 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 two sentences with no wasted words. It front-loads the purpose and then lists return fields and usage guidance. 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?

Given the simple input schema, presence of output schema, and comprehensive annotations, the description covers the essential use case. It mentions usage after subscribe and key return fields. Minor gaps: it does not explicitly mention that the subscription must exist or error behavior, but the agent can infer from the operation type. Overall, sufficient for correct selection and invocation.

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

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

Schema coverage is 100% and the parameter 'subscriptionId' already has a clear description in the schema ('UUID returned by intelligence.subscribe'). The tool description does not add additional semantic meaning beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Check the status') and resource ('intelligence subscription by ID'), explicitly lists the returned fields (signal score, last fired timestamp, etc.), and distinguishes itself from sibling tools by mentioning its relationship to 'intelligence.subscribe' and implicitly differentiating from 'intelligence.subscription.delete'.

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 this tool: 'Use after intelligence.subscribe to verify a subscription is active.' This provides clear usage context. However, it does not explicitly state when not to use it or mention alternative tools for other scenarios (e.g., listing all subscriptions), though the sibling set makes the purpose clear enough.

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. The description adds value by detailing the return structure (per-node stress state, rupture sequence, horizon timeline, AI synthesis briefing) and confirming it is a GET request with no input. 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 five sentences, each contributing distinct value: domain & scope, node attributes, sibling contrast, output summary, and input requirement. It is well-structured, front-loaded, and contains no fluff.

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, has an output schema, and rich annotations, the description is complete. It explains the tool's purpose, data composition, outputs, and usage context. The sibling contrast and domain listing provide sufficient context for an agent to decide when 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 has zero parameters, and the schema coverage is 100% (empty). The description explicitly states 'No input required', which is sufficient. The baseline for 0 parameters is 4, and the description meets 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 maps slow-moving structural stress across 22 fault lines in 5 domains, provides specific metrics per node, and explicitly contrasts with the sibling tool market.cascade. The verb+resource is specific and unambiguous.

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

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

The description gives a direct comparison with market.cascade (acute shock vs. latent pressure), helping the agent choose between them. It also states 'No input required', simplifying usage. However, it does not explicitly exclude other intelligence tools (e.g., aftershock, contagion) or provide broader usage 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?

The description reveals that the tool creates an invoice (write behavior) and returns an invoiceId and payUrl, and that invoices expire. With annotations providing no safety hints, the description adds moderate transparency but does not discuss idempotency, error cases, authentication requirements, or side effects beyond creation. 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 sentences deliver the core purpose, workflow, return values, and expiration. No filler words. Information is front-loaded, and each sentence adds value without redundancy.

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

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

The description covers the main flow, expiration, and references the complementary invoice.pay tool. Given the output schema exists (not shown), it is acceptable that return values are not fully detailed. However, it does not mention what happens if the invoice is never paid, duplicate creation attempts, or how the callbackUrl fits in. Slightly incomplete for a tool with 7 parameters and no error notes.

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 does not add extra semantic details for individual parameters beyond the schema descriptions. It does provide flow context (Agent A requests payment from Agent B) which indirectly helps interpret parameters like recipientAddress, but this is not explicit parameter-level enrichment.

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 creates an agent-to-agent invoice, specifies which agent initiates (Agent A) and which pays (Agent B), and mentions the returned invoiceId and payUrl. This distinguishes it from sibling tools like 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 provides a clear workflow: Agent A creates the invoice, Agent B pays via invoice.pay. It mentions expiration and default TTL. However, it could explicitly state when not to use this tool (e.g., do not use to pay an invoice) and mention alternatives beyond invoice.pay.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. Description adds value by specifying the status enum (OPEN/PAID/EXPIRED) and the workflow recommendation. 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 succinct sentences: first defines purpose and return fields, second provides a usage guideline. No extraneous information, 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?

For a simple retrieval tool with a single parameter, existing annotations, and an output schema, the description covers all necessary context: purpose, returned fields, and workflow integration.

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 invoiceId described as 'Invoice UUID returned by invoice.create'. The tool description echoes 'by ID' and 'Invoice UUID' without adding significant new 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?

Description states 'Retrieve an agent-to-agent invoice by ID' – a specific verb+resource. It lists returned fields (status, amount, currency pair, payUrl) and distinguishes from siblings 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?

Explicitly says 'Use before calling invoice.pay to confirm the invoice is still OPEN.' This provides clear when-to-use advice and a precondition check.

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 readOnlyHint=false (mutating) and destructiveHint=false (not destructive). The description adds behavioral details: it retrieves the invoice, runs settlement via POST /settle, and marks it PAID. It also explains sandbox vs. live mode outputs. This goes beyond annotations by clarifying the multi-step process and simulation behavior. However, it does not mention possible failure modes or side effects like fees.

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, with no wasted words. It front-loades the purpose, then explains the process, and finally distinguishes output by mode. Every sentence serves a clear function, making it efficient and easy to parse.

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 an output schema (external), so the description needn't detail return values. It covers the core workflow, sandbox vs. live behavior, and references the settlement endpoint. However, it could be more complete by mentioning prerequisites (e.g., invoice status) or potential failures. Given the moderate complexity (payment + settlement + on-chain), the description is sufficiently complete but not exhaustive.

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

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

Schema coverage is 100%, so the schema already documents all three parameters (invoiceId, sandbox, recipientAddress). The description adds only minimal context: it notes that sandbox mode returns a simulated receipt. It does not explain recipientAddress's conditional requirement beyond the schema's existing note. Thus, the description adds little value beyond the schema, earning the baseline of 3.

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

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

The description clearly states the tool pays an agent-to-agent invoice by ID, with a specific verb ('Pay') and resource ('agent-to-agent invoice'). It outlines the steps (retrieve, settle, mark PAID) and distinguishes from sibling tools like invoice.create (create) and settlement.execute (separate settlement). This makes the purpose unambiguous and well-differentiated.

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

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

The description implies the tool is for paying invoices by ID, but it does not explicitly state when to use it versus alternatives (e.g., settlement.execute or other payment flows). No prerequisites or post-conditions are mentioned, such as the invoice needing to exist or be in a specific state. The usage guidance is adequate 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, destructiveHint=false. The description confirms it returns data but adds no additional behavioral context (e.g., pagination, rate limits, error handling). It meets the baseline but does not exceed it.

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

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

Three sentences, front-loaded with the primary action and return values, followed by usage guidance. Every sentence is necessary 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?

For a simple read tool with one parameter and no output schema, the description fully covers what the tool does, what it returns, and when to use it. No critical gaps remain.

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

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

The sole parameter session_id is already described in the schema. The description adds value by clarifying that the ID is the same one used in receipt.create calls, providing helpful cross-reference context beyond the schema.

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

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

The description clearly states the tool retrieves aggregated payment data for a multi-agent session, specifying the exact return fields (total USD moved, transaction count, chronological list). It distinguishes itself from siblings like receipt.create by focusing on session-level aggregation.

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 three use cases: cost accounting, audit, and showing human what an agent run spent. While it does not mention when not to use it or alternatives, the guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: the output is a time-ordered cascade chain with attenuated signal strength and an AI synthesis briefing. It also clarifies that the tool is purely macro intelligence with no settlement or stablecoin mechanics. This goes beyond the annotations and provides behavioral transparency about the type of output and scope.

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 well-structured and efficient. The first sentence establishes the core purpose, the second sentence lists the inputs and outputs, the third sentence enumerates the 24 nodes across 4 domains, and the final sentence clarifies scope. Every sentence is necessary and contributes to understanding. It is front-loaded with the most important information.

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

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

Given the tool's complexity (5 parameters, output schema exists), the description is quite complete. It explains how to use listNodes, what the output includes, and what domains are covered. It also explicitly states what it does not cover (settlement/stablecoin). The only minor gap is that it does not describe the output format in detail, but since an output schema is provided, that is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds extra value: it explains the purpose of listNodes (discover valid IDs), gives concrete examples for eventType, defines magnitude scale with examples (100 = maximum plausible shock), and suggests horizonHours values (24 for immediate, 720 for 30-day). This enriches the parameter semantics beyond the schema.

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

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

The description clearly states the verb ('models how a shock propagates') and resource ('macro domains across climate, geopolitical, economic, and commodity systems'). It lists specific node examples and explicitly distinguishes itself from settlement/stablecoin tools, which is a strong differentiator from siblings like intelligence.contagion or forecast.scenario.

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 explains how to use the tool: call with listNodes first, then provide origin, eventType, magnitude, horizonHours. It also gives example values for magnitude and horizonHours. However, it does not mention when to use this tool versus alternatives (e.g., intelligence.aftershock or intelligence.tectonic), nor does it state when not to use it. The usage guidance is adequate but not explicit about exclusions.

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