gblin-treasury-risk-regime

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

Annotations already declare readOnly, idempotent, non-destructive, which the description reinforces. It adds valuable behavioral context: 'Every output bound is non-zero and every step through the vault or the Zap carries its gas limit' and 'in the order to send them.' It also clarifies that nothing is signed or sent, which is a non-obvious behavior for a 'prepare' tool. 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 dense but efficient: it opens with the purpose, enumerates each action with its amount semantics in a compact list, and finishes with essential behavioral notes. Every sentence earns its place, and the information is front-loaded. 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 an output schema exists (not shown but noted), the description doesn't need to detail return values. It covers the workflow (preview, prepare, send), the actions, amount meanings, gas limits, and ordering. It doesn't mention prerequisites like wallet balance or approvals, but those are likely outside the tool's responsibility. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

While the schema provides 100% coverage of parameters, the description adds critical action-specific meaning for the 'amount' parameter (e.g., 'amount in ETH' for mint_with_eth, 'amount = the USDC you need' for exit_to_usdc) and explains the optional 'row' default for bid. This is exactly the kind of contextualization the schema alone cannot convey, and it prevents misuse.

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 builds unsigned transactions for vault operations, names the exact actions it supports, and distinguishes itself from siblings like actions.preview and payments.prepare by specifying the vault context and the non-execution nature ('Nothing is signed or sent'). It goes beyond a generic phrase and gives concrete scope.

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

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

It explicitly advises the workflow: 'simulate the steps with preview_steps, then send them from the wallet.' This tells the agent when to use this tool relative to preview. It also clarifies that it is for vault operations and lists the supported actions, implying it's the preparation step for those. It does not explicitly contrast with payments.prepare, but the vault-specific actions make the distinction 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?

Adds significant context beyond annotations: explains sequential state propagation, per-step results including gas and revert reasons, net movements, and the crucial caveat that state can change so success is evidence, not guarantee. 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?

Description is well-organized: first sentence states purpose, second details outputs, third gives input guidance, fourth warns about state changes. Every sentence earns its place 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?

Complete for a simulation tool: covers input format, output, and caveats. Output schema exists, so return details are covered. No missing critical information for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable guidance on constructing steps, specifying they should come from prepare_action or related functions, and clarifies optional value and gas in wei. This elevates it above baseline.

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

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

The description clearly states the tool simulates a sequence of transactions against the latest Base block before signing. It uses a specific verb ('simulate') and resource ('list of transactions'), and the context 'before anything is signed' distinguishes it from siblings like prepare or status.

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

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

The description provides clear context: use to preview before signing, and instructs to pass steps exactly as returned by prepare_action, invest_usdc_to_gblin, or swap_gblin_to_usdc_jit. However, it doesn't explicitly mention alternatives or exclusions, so it relies on implicit differentiation.

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

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

Even with annotations already declaring readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, the description adds substantial behavioral detail: it reports statuses, block and confirmations, fee, net token movements, and decoded revert reasons. This goes well beyond the annotations and informs the agent what kind of output to expect.

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 not bloated. It front-loads the core purpose, then lists the key reported fields, and closes with a clear usage instruction. Every clause contributes useful detail for tool selection and invocation.

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 a single well-documented parameter, an output schema, and annotations covering safety, the description provides sufficient context: when to call it, what it reports, and how it fits into the prepare_action workflow. Nothing essential is missing.

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

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

Schema description coverage is 100% and the only parameter, hash, is already described as 'The transaction hash.' The description confirms it refers to a sent Base transaction but does not add meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb ('Report') and resource ('what a sent Base transaction did'), then enumerates concrete outcomes: pending, succeeded, reverted, or not found. This distinguishes it from sibling tools like actions.prepare and actions.preview, which clearly operate at different stages.

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 tells the agent when to use this tool: 'after sending the steps from prepare_action to confirm each one before the next.' This is clear contextual guidance, though it does not name alternative tools or explicitly state when not to use it.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds substantial behavioral detail beyond that: it is free/no payment, runs four specific checks, uses a 10-minute TTL with on-chain time, and only recovers the signer when a signature is present. This is far more transparent than the 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 front-loaded with the primary purpose, then efficiently lists the four checks in a numbered format. Every sentence earns its place, and the length is justified by the complexity of the verification logic.

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 what the tool does, the input provenance, the checks performed, time-based behavior, and when to use it. An output schema is present, so documenting return values is unnecessary. Nothing essential is missing for an agent to 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%, so the baseline is 3. The description adds some semantic context by explaining that the attestation may be a peer-attached proof-of-diligence rather than only an API response, but the parameter-level details are already well captured 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 opens with a specific verb and resource: 'Verify a GBLIN Risk Attestation.' It further specifies the provenance of the object and enumerates the four distinct checks, making it unmistakably different from sibling tools like payments.verify or receipts.verify.

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

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

The last sentence gives explicit when-to-use guidance: 'Use before you trust any counterparty/peer that claims it checked market risk via GBLIN.' It does not explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to select it over other verify tools.

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

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

Beyond the readOnlyHint, the description discloses meaningful behavioral mechanics: the vault does not self-rebalance and pays no external party, the Dutch auction ramps a premium from discount to cap, and the premium is the entire reward while nothing is paid out of the vault. This adds substantial context 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 dense, purposeful sentences. It front-loads the core action, then explains the mechanism, then enumerates the returned fields. Every sentence contributes either to scoping or to behavioral understanding; there is no filler.

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

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

For a zero-parameter read-only tool with an output schema, the description is complete. It specifies the network (Base), the resource (GBLIN rebalancing auction), the auction mechanism, the exact per-row return fields, and the reward economics. Nothing necessary for correct invocation 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, so the description need not explain parameters. Per the baseline for zero-parameter tools, the score is 4; the description appropriately focuses on output semantics instead.

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: 'Read the GBLIN rebalancing auction on Base.' It clearly identifies what the tool does and distinguishes it from sibling action-oriented tools by emphasizing read-only observation and returning state data rather than executing anything.

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

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

The description makes the use case clear: it is the tool for inspecting the current rebalancing auction state, including bidder-side calldata. It does not explicitly name alternatives or state when not to use it, but the read-only framing and detailed output description provide clear context without exclusions.

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

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

Given annotations already declare read-only, open-world, idempotent, and non-destructive hints, the description adds value by clarifying the data source (self-observation, v0), the frequency (every 10 minutes), and the sealing mechanism (EAS attestation on Base). This goes beyond mere reputation and provides useful 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 concise at about 40 words, with all information relevant. It front-loads the core purpose (tallies) and then adds necessary detail. 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?

The description is sufficient for a zero-parameter, read-only report with annotations and an output schema. It explains the data source, frequency, and sealing, but could offer a bit more on the exact contents of the report (e.g., what fields are included). However, given the output schema exists, the description need not detail return values, so this is adequate.

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, so the description does not need to explain parameters. Since there are no params, the description's job is to set expectations, and it does so by describing what is included in the report. A baseline of 4 is appropriate because the description compensates for the lack of param details.

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: reporting kept/violated tallies for GBLIN's hash-pinned promises, with details on how data is collected (every 10 minutes) and sealed (EAS attestation on Base). It distinguishes itself from siblings by focusing on tallies and attestation, which is unique among the listed tools.

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

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

The description implies its use for checking compliance tallies and notes that it is self-observation only in v0, which gives context but does not explicitly state when to use this tool versus alternatives. It could benefit from mentioning that this is for read-only reporting, but the self-observation note provides some guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructiveness, and the description reinforces 'Read-only' without contradicting them. It adds useful behavioral detail beyond the annotations by specifying exactly what state is inspected (e.g., 'surfaces any pending asset-addition proposal') and that providing operation_id changes the reported outcome.

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

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

The description is front-loaded with the core purpose and uses three sentences to enumerate checks and usage, with minimal waste. The 'Read-only' phrase slightly duplicates the annotation, but the appended usage guidance justifies the sentence.

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 parameter schema, rich annotations, and presence of an output schema, the description covers purpose, scope, optional behavior, and usage context. It does not discuss rate limits or explicit alternatives, but those are not critical for this read-only governance inspection 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 sole parameter operation_id has 100% schema description coverage, so the schema already documents its format and purpose. The description adds that providing it 'also reports the status of that specific timelock operation,' which reinforces but does not significantly extend the structured 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 states a specific verb and resource: 'Verify GBLIN protocol governance state' and enumerates the concrete checks (vault ownership, timelock delays, role counts, pending proposals, operation status). It is clearly distinguishable from action-oriented siblings such as actions.prepare or payments.relay by its read-only governance scope and explicit 'Read-only' marker.

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

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

The description gives clear application context: 'use this to gate trust-sensitive agent actions' and explicitly notes the optional operation_id behavior. It does not name alternative tools or state when not to use it, but the purpose is specific enough that an agent can infer when governance.state is the right choice over treasury.state or protocol.info.

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

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

Adds substantial behavior beyond annotations: the operation is gasless, no private key is requested/held/transmitted, the EIP-712 domain is read from the token rather than assumed, and method choice has front-running implications. It also explains relay behavior and the returned artifacts, giving the agent expectations the annotations alone cannot convey.

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?

Seven sentences, each carrying distinct information: what it builds, why it is gasless, what it returns, method selection, relay behavior, and key-handling guarantees. The description is front-loaded with the core purpose and contains no filler sentences.

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

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

For a complex preparation tool with an output schema, the description covers return payloads, method semantics, relay dependencies, and security model. The 100%-covered schema handles parameter-level details, so nothing critical is missing for an agent deciding whether and how to call this tool correctly.

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

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

The schema already covers all 7 parameters (100%), so the baseline is 3. The description adds meaningful context: 'from' is the signer and no key touches the server, 'receive' vs 'transfer' maps to submission rights, and relay forces method 'transfer'. This goes beyond the schema without redundant restatement.

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

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

States a concrete verb and resource: 'Build a gasless GBLIN payment.' It explains the EIP-3009 mechanism, what the tool returns (EIP-712 message, calldata, x402 payload), and distinguishes the 'receive' vs 'transfer' modes. This makes the tool's role clear even among payment-related siblings.

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

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

Provides explicit decision rules: use 'receive' for a known recipient to prevent front-running, use 'transfer' for an x402 facilitator, and set relay:true when nobody else will carry the payment. It does not directly contrast this tool with sibling prepare tools like actions.prepare, so it stops short of full when-not guidance.

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

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

Beyond annotations, the description reveals atomic submission via Multicall3, chain-checking and simulation, live-NAV fee payment, and return of transaction hash/outcome. It also explicitly warns that this moves funds, reinforcing the destructiveHint annotation with actionable 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 front-loaded with the core purpose and then compactly covers payload, execution behavior, fee, return value, and a safety warning. Every sentence contributes necessary information and there is no filler.

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

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

For a tool with nested parameters, atomic on-chain execution, and an output schema, the description covers prerequisites, mechanics, return value, and risk. Nothing an agent needs to decide whether and how to invoke it is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful provenance: both payment and fee must come from prepare_gblin_payment with relay: true and be signed by the payer's wallet, which is not fully captured by the schema alone.

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

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

The description states a specific verb ('relay') and resource ('signed GBLIN payment on chain') and clarifies the niche use case: a payer holding no ETH. It clearly differentiates itself from prepare/verify sibling tools by describing the on-chain submission step.

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

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

It gives clear context: use this when the payer holds no ETH and when authorizations were prepared with relay: true. It also warns to run it only with authorizations the payer meant to sign. It does not explicitly name alternative tools or when-not conditions, but the usage context is unambiguous.

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

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

The description discloses the full verification pipeline: EIP-712 signer recovery, ERC-1271 for contract payers, validity-window/nonce/balance checks, and the return semantics. Annotations already mark the operation read-only and idempotent, and the description adds rich behavioral detail 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?

Every sentence earns its place: purpose, internal checks, return behavior, and operational significance. The most decision-relevant information is front-loaded, and there is no filler.

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

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

For a complex verification tool with an output schema and safety annotations, the description is complete: it covers what is checked, what is returned, and what the result means in the x402 flow. Nothing critical for selecting or invoking the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents authorization, signature, and method. The description adds behavioral context about the digest and signer recovery, but it does not add separate parameter-level meaning beyond the schema, matching the baseline for high 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 specific verb and resource: 'Check a signed GBLIN authorization against the chain before spending gas on it.' It distinguishes itself from payment lifecycle siblings by focusing on verification rather than preparation or relay, and it explicitly describes the verdict/calldata outcome.

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

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

It clearly establishes the usage context: run this before spending gas, and a 'would_settle' verdict means the payment is good to carry. However, it does not explicitly name the sibling tools or state when not to use it, so it falls just short of fully explicit routing.

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 show readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds that the output is plain text and lists contents, but it does not disclose any limitations, rate limits, or output details beyond what the annotations already convey.

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 sentence that is front-loaded with the core resource name and format, followed by a compact, useful list of contents. There is no redundant wording.

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

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

Given no parameters, an output schema, and simple annotations, the description is sufficiently complete for a protocol information fetch. The only notable gap is the lack of explicit usage guidance relative to sibling tools, which may still be inferred.

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

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

With zero parameters and an empty input schema, the description carries the full semantic burden and does so by indicating exactly what kind of data will be returned. No parameter-level documentation is needed.

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

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

The description clearly states that protocol.info returns 'GBLIN llms.txt as plain text' and lists its contents: contract addresses, endpoints, prices, payment flow, and field contract of the attestation. This identifies the resource and distinguishes it from sibling tools like protocol.stats and receipts.get, though it lacks an explicit verb like 'retrieve'.

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 when protocol-level information is needed, but it does not explicitly state when to use this tool versus alternatives or mention exclusions. For a simple zero-parameter read, this is adequate but not fully 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 flag read-only, open-world, idempotent, and non-destructive behavior, so the description only needs to add non-obvious context. It adds 'Cached 5 min' (stale data window) and 'methodology disclosure', which are useful beyond structured annotations. 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?

Two short sentences front-load the counters and add only the cache and methodology caveats. No filler, no repetition of schema or annotations.

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

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

An output schema exists, annotations are rich, and no parameters require explanation. The description covers data scope, freshness via 'Cached 5 min', and methodology disclosure. This is complete for a no-input stats tool.

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

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

The tool has zero parameters and the schema is fully self-describing with additionalProperties false. The description therefore does not need to explain inputs. Baseline 4 applies.

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

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

The description opens with 'Cumulative public counters of GBLIN's x402 endpoints' and enumerates paid calls, unique payer wallets, USDC earned, and methodology disclosure. This clearly identifies the tool as an aggregate stats endpoint, distinct from receipt/risk/info siblings. The metric scope is unambiguous.

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

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

The 'cumulative public counters' phrasing and 'Cached 5 min' note establish when this tool is appropriate: for aggregate, quick, read-only metrics. It does not explicitly name alternatives, but no exclusions are needed for a zero-parameter stats endpoint. The context is clear enough for selection among siblings like receipts.get.

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 genuine context beyond those hints: it discloses that the receipt is re-signed with a fresh inclusion proof, explains why re-signing yields deterministic output ('Ed25519 is deterministic'), notes the response includes the current signed checkpoint and latest on-chain anchor, and states it is free. This gives the agent useful behavioral expectations without contradicting the annotations.

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

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

The description is one dense sentence plus 'Free.', with the core resource (receipt from the log) front-loaded. Every phrase earns its place — re-signing, inclusion proof, checkpoint, anchor — and the parenthetical on Ed25519 determinism explains a non-obvious property. Slightly telegraphic, but appropriately sized with essentially 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?

The tool is simple (one required parameter, fully described in schema), has an output schema so return format need not be spelled out, and annotations cover the safety profile (read-only, idempotent, non-destructive). The description enriches this with the response contents and cost. Missing only minor context like rate limits or what GBLIN's log is, which are not necessary for correct invocation.

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

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

Schema description coverage is 100%: the 'index' parameter is fully documented in the schema ('Receipt index in the log (0-based; current size at GET /log/checkpoint)'). Per the baseline for high schema coverage, the description need not repeat parameter details; its 'Receipt #index' phrasing aligns with the schema. The description adds no new parameter semantics, but none are required.

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 specifies the resource precisely — a receipt from GBLIN's receipts log — and enumerates what is returned (re-signed receipt, inclusion proof, signed checkpoint, on-chain anchor). The annotation title 'Get a receipt by index' supplies the explicit verb. It is clear what the tool does, though the description itself reads as a noun phrase and does not explicitly contrast with the related siblings receipts.seal and receipts.verify.

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

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

The description offers no guidance on when to use this tool versus alternatives. Siblings like receipts.seal and receipts.verify are functionally adjacent, but the description never says 'use this to fetch an existing receipt; use receipts.verify to check one' or any exclusion. Nothing is misleading, but the agent is left to infer the usage 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?

The description adds significant behavioral context beyond annotations: fields are published publicly, secrets must not be included, provenance is self-reported, demo receipts are marked demo:true, and unspecified fields are ignored. No contradiction with annotations exists.

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

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

The description is dense but every sentence carries essential information: core behavior, mode constraints, alternative endpoint, provenance caveat, privacy warning, and ignored-field behavior. It is front-loaded with the primary action and return value.

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

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

The description is complete for a tool with this complexity: it explains the mutated state (public log append), the receipt contents, rate limits, alternative paid access, and privacy implications. An output schema exists, so detailed return-field documentation is not required here.

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 each parameter. The description adds value by emphasizing that action/agent_id/tool/meta are published, that only identifiers should be used, and that unlisted fields are ignored and not recorded.

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

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

The description states a specific verb+resource: appends hashes to a transparency log and returns a portable receipt. It clearly differentiates from sibling tools like receipts.get and receipts.verify by describing creation/publication rather than retrieval or verification.

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

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

It explicitly states that demo is the only mode over MCP, gives the rate limit, and points to the paid x402 endpoint for unlimited seals. It does not explicitly describe when to choose this over sibling receipt tools, but the creation vs. retrieval/verification distinction is strongly implied.

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

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

While annotations already declare readOnlyHint, idempotentHint, and destructiveHint, the description adds meaningful behavioral context: it performs verification without log lookups (i.e., no server-side state), equivalent to an offline script, and does not perform on-chain anchor checks (pointing to another endpoint). This transparency about what the tool does and does not do goes 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 two sentences of substantive content plus a third sentence pointing to an alternative. It front-loads the purpose, lists specific checks, and includes a clear pointer to related functionality. 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?

The tool is cryptographically complex, but the description covers its core behavior, the exact checks, the lack of trust assumptions, and references an offline script for reproducibility. An output schema exists, so return value details are not needed. The pointer to the alternative endpoint fills the only gap (on-chain consistency). This is fully complete for an agent to decide and invoke correctly.

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

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

The schema describes the single parameter 'receipt' with its expected format (bare or wrapped in {receipt}) and sources. The description adds the version specifier 'gblin-receipt/v1' and clarifies it's JSON, but these are minor additions. Since schema coverage is 100%, the description provides modest extra value, warranting a 4 rather than the baseline 3.

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

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

The description starts with the specific verb 'Verify' and identifies the exact resource: 'a gblin-receipt/v1 JSON'. It enumerates the specific checks performed (leaf hash, Ed25519 signature, RFC 6962 inclusion proof, etc.), which clearly distinguishes it from sibling tools like receipts.seal or receipts.get. The phrase 'pure math (no log lookup, no trust in this server)' differentiates it further from trust-based checks.

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: to verify a receipt with pure math and no trust in the server. It also provides an alternative for a different need: 'For the extra on-chain-anchor consistency check use GET /v1/verify/:index.' This gives clear context and exclusions, making the usage boundaries 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 read-only, idempotent, and non-destructive behavior. The description adds meaningful context: the sample is static, permanently expired, and schema-compatible with the paid attestation, which is valuable beyond the annotations. No contradiction exists.

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

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

The description is two sentences with no filler. It front-loads the core identity and state of the resource, then gives a direct use-case instruction.

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

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

With no parameters, supportive annotations, and an output schema present, the description fully covers what an agent needs to know: what the sample is, its constraints, and how to use it. Nothing essential is missing.

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

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

The tool has zero parameters, so the schema requires no parameter documentation. Per the baseline for 0-parameter tools, a score of 4 is appropriate since there is nothing the description needs to compensate for.

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

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

The description clearly identifies the tool as a static, permanently expired sample of the signed Risk Attestation, with the same fields and EIP-712 schema as the paid version. It states a specific purpose (building/testing a parser/verifier) and distinguishes the sample from the paid attestation.

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 to use the tool to build and test a parser/verifier, which is clear usage guidance. It also notes the sample is permanently expired, implying it is not for production or current attestation data, though it does not explicitly name sibling 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?

The description adds valuable behavioral context beyond the annotations: 'read live', '60s cache', 'free and unsigned', and the existence of a signed paid endpoint. This discloses data freshness and auth/security nuances without contradicting the readOnlyHint.

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 tight sentences. The first sentence delivers the core purpose and source; the second covers licensing/caching/alternative. No filler.

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

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

For a zero-parameter tool with an output schema, the description covers the essential context: what, where, how fresh, and what alternatives exist. Nothing 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?

With zero parameters and 100% schema coverage, the baseline is 4. The description doesn't need to add parameter info and appropriately focuses elsewhere.

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 the current BTC/ETH risk regime (calm | elevated | crash) with a suggested posture, and specifies the source (GBLIN's on-chain Crash Shield on Base). This is a specific verb+resource that distinguishes it from sibling tools like risk.attestation_sample.

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 about the free, live endpoint vs. a paid signed alternative, implying when to use each. However, it could be more explicit about when NOT to use this tool (e.g., when offline verification is needed).

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 non-destructive behavior; the description adds valuable behavioral context beyond those hints by disclosing the cost model ('Free by default; metered at $0.003 USDC only when the operator sets MCP_PAYWALL=true'). It also explains the conditional output behavior tied to daily_burn_usd.

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

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

Two dense sentences with no filler. The first front-loads the purpose and metric list; the second adds the only non-obvious operational detail (cost/paywall). Every clause earns its place.

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

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

With an output schema present and annotations covering safety, the description provides everything an agent needs to call correctly: what to pass, what output dimensions to expect, and when the optional param changes behavior. The paywall semantics and conditional recommendation are fully specified.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema by explaining the effect of daily_burn_usd: it produces days of USDC runway and a recommendation about the GBLIN surplus. Wallet_address and _payment are adequately served by the schema.

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

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

The description opens with a specific verb and resource ('Analyze an agent wallet's treasury health') and then enumerates exact metrics: GBLIN/USDC/ETH balances, ETH exit coverage at live gas price, redemption cooldown, and optional runway. This level of specificity makes it clearly distinct from sibling treasury tools like treasury.quote or treasury.state.

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 context for use is clear: call this when you need treasury health diagnostics for an agent wallet. It also gives a conditional usage rule ('if daily_burn_usd is provided') for getting runway and a recommendation. However, it never explicitly names alternatives or when-not-to-use conditions, so it stops short of full routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral details beyond annotations: it reads from the chain at past blocks, includes oracle prices, changes, and largest drawdown, and notes the history start point. No contradictions with annotations.

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

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

The description is three sentences, front-loaded with the core data returned, then adds history start and a usage note. It is efficient with no redundant phrasing, though the second sentence about history start could be integrated more tightly. Still, it is concise and well-structured.

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

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

The description covers the returned data (NAV, oracle prices, changes, drawdown), the historical scope (since deployment), and a clear use case. An output schema exists, so return format is likely covered. Minor omission: no mention of pagination or limit behavior, but that is in the schema. Overall complete for a read-only historical tool.

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

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

Schema description coverage is 100%, with both parameters (points and interval) having clear descriptions and defaults. The description does not add extra parameter-specific details but provides context about the data returned. Since the schema already documents parameters, the baseline of 3 is appropriate.

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

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

The description clearly states the tool returns NAV per GBLIN share over time, along with ETH/USD and BTC/USD oracle prices, changes, and drawdown. It specifies the resource (NAV history) and the verb (read), making it distinct from siblings like treasury.state or treasury.quote, which focus on current values.

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 an explicit use case: 'Use it to judge how the index behaved against holding ETH or BTC over the same span.' This gives clear context for when to call the tool, though it does not mention alternatives or explicitly state when not to use it. The context of 'history' and 'over time' implicitly separates it from current-state tools.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses meaningful behavior: it returns expected output, a safe minOut with a dynamic slippage buffer (2.5% normal / 4% during Crash Shield), and a fee breakdown. This adds real context about what the call yields and its side-effect-free nature, with no contradictions.

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

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

Two dense sentences front-load the core purpose and then pack in return values, slippage policy, and fees without wasted words. The 'Read-only' tag is redundant with annotations but harmless and brief.

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 two parameters, an output schema, and strong safety annotations, the description supplies all necessary behavioral context: non-execution, direction semantics, slippage policy, and fee reporting. Nothing an agent needs to choose or invoke it correctly is missing.

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

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

The description adds meaning to the direction enum by defining buy as ETH→GBLIN and sell as GBLIN→ETH, which complements the schema's amount_in note. With 50% schema description coverage, this mapping meaningfully reduces ambiguity, although the description does not explicitly re-explain every parameter.

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

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

The description opens with a precise verb and scope: 'Preview a buy (ETH→GBLIN) or sell (GBLIN→ETH) without executing.' It clearly differentiates itself from execution-oriented siblings by stating it does not execute and is read-only, and the title reinforces the quote/mint/redemption purpose.

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

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

It provides clear context: use this tool when you need a non-executing preview of a mint or redemption quote. It does not explicitly name alternative tools or say when not to use it, but 'without executing' and 'Read-only' are strong usage signals that prevent confusion with execution tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds the Base mainnet context and the specific data it surfaces, which is useful but not deeply behavioral. No contradiction or additional side-effect information is provided.

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, both informative and directly useful. The first sentence states the core purpose and data content; the second provides actionable placement guidance. No filler or redundant restating of schema or annotations.

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

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

This is a simple, zero-parameter read tool with a full output schema and strong annotations. The description covers what it returns, where it operates, and when to call it. Nothing essential is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter semantics to document. Per the baseline for zero-parameter tools, the description adequately conveys that no input is needed to read the current global protocol state.

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

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

The description states a specific verb ('Read'), a specific resource ('GBLIN protocol state on Base mainnet'), and the key data exposed (NAV in USD, basket composition with dynamic weights, Crash Shield status). This clearly identifies the tool's purpose and differentiates it from siblings like treasury.quote or treasury.nav_history.

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 to use this tool BEFORE any swap to know the current price and risk regime, which is strong usage guidance. It does not explicitly name alternatives or exclusion conditions, but the 'before a swap' context is clear enough for an agent to select it appropriately.

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