Wever Pay Exchange

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

Annotations already declare this is a non-read-only, open-world, non-destructive operation. The description adds real behavioral value beyond that: it explains that the exchange derives and verifies the bound EVM source, asset, amount, recipient, and transaction uniqueness before any ledger credit, which tells the agent the call is validating and may reject the claim. It stops short of describing failure modes or the resulting ledger state.

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, front-loaded with the action and resource, then the verification behavior. The second sentence is dense with jargon ('canonical ledger credit') but every clause carries meaning; 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 mutating, open-world tool with four fully required parameters and no output schema, the definition covers purpose and verification but omits return semantics, idempotency behavior, and rejection/retry handling. An agent could invoke it but would not know what a successful response contains or how to interpret a failed verification.

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 0%, so the description must carry the parameter burden and only partly does: 'owned wallet' maps to walletId, 'amount' to amountMinor, and 'unique transaction' to transactionHash. The idempotencyKey parameter is never mentioned, and no format or unit expectations are added beyond what the schema pattern/minimum already enforce.

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

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

The description gives a specific verb and resource: claim a completed external Base mainnet USDC transfer for an owned wallet. It clearly separates this from read-side siblings like get_external_funding_instructions or get_balance, though it never names an alternative tool explicitly.

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

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

The phrase 'completed external ... transfer' implies the prerequisite that funds have already been sent on-chain, which is useful context. However, there is no explicit when-to-use versus when-not guidance, no pointer to the sibling that provides funding instructions, and no note on what to do if verification fails.

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

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

Annotations already establish readOnly=false, openWorld=true, and destructive=false. The description adds meaningful behavior: it creates or replays an account and activates credential generation, which clarifies side effects and idempotency beyond the annotation flags. 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 a single dense sentence with no filler, using parallel clauses to convey three distinct effects. It front-loads the core requirement of proving Ed25519 key control and wastes no 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?

This tool has high complexity (nested proof rules, required digests, scopes) and no output schema, yet the description gives no context about the registration workflow, prerequisites like obtaining a challenge, or what happens during replay. It is too terse to fully guide 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 0% and the description makes no attempt to explain the 'completion' object or map its high-level actions to required fields. The agent is left entirely to the schema's structural constraints, which is insufficient for a complex nested cryptographic payload.

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 concrete actions — prove Ed25519 key control, create or replay the canonical exchange account, and activate credential generation — so the agent can tell what the tool does. However, it never explicitly differentiates this from siblings like request_participant_challenge or get_participant_registration_requirements, so it lacks clear sibling differentiation.

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

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

The description gives no guidance on when to call this tool, what preconditions exist (e.g., a prior challenge), or how it fits into the registration flow. The phrase 'create or replay' hints at idempotency but does not provide operational sequencing or alternative 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 signal a non-read-only, non-destructive write with an open world; the description adds meaningful context by requiring prior ownership proof and by noting that limits are scoped per verified identity rather than globally. No contradictions with annotations. It does not detail idempotency/duplicate behavior or exact side effects, but the annotation set lowers that 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?

Two focused sentences, front-loaded with the action and prerequisites. The second sentence adds a material business rule with no waste; every clause has signal.

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

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

The description provides the precondition, permitted roles, and scoping rule, and the schema supplies required patterns and enum. However, it is a creation/write tool with no output schema, and the description does not mention expected return value, idempotency semantics, or failure/duplicate behavior, leaving clear 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?

With 0% schema description coverage, the description must carry parameter meaning. It explains the role enumeration (BUYER/SELLER) and points to EVM ownership proof, which maps to ownershipProof and address. It does not elaborate on idempotencyKey or displayName, though those are fairly self-explanatory; the compensation is partial but not missing.

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 action ('Create or bind') and a specific resource ('permitted BUYER or SELLER wallet'), and adds the key contextual scope of the authenticated agent and EVM ownership proof. This distinguishes the tool from read/support siblings like get_wallet and other wallet-related operations.

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

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

It states the precondition 'after EVM ownership proof' and clarifies the wallet role scope, making the intended use case clear. It does not explicitly name alternatives or say when not to use this tool, but the usage context is strong enough that an agent can decide correctly.

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 read-only nature is established elsewhere. The description adds only a scope qualifier ('signed-offer commerce') and no further behavioral detail such as return format, pagination, or what this discovery actually performs.

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 with no filler. It is efficient, though it is terse enough that brevity comes at the cost of the guidance and context that other dimensions penalize.

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 output schema and no parameters, the description carries the full burden of explaining what the caller will get. It does not state what the returned discovery result looks like, what 'assurance services' includes, or how this tool relates to the sibling discovery tools, leaving a significant completeness 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?

The input schema has zero parameters and its coverage is effectively 100%, so there is nothing for the description to clarify. The zero-parameter baseline of 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 uses a specific verb ('Discover') and names a resource ('signed-offer commerce assurance services'), so it is not merely a tautology. However, it does not define what 'assurance services' are or differentiate them from the many sibling discovery/search 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?

No guidance is given for when to use this tool versus siblings such as discover_commerce_index, search_verified_offers, or get_verified_offer. The operator must infer selection entirely from the name and one-line description.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' matches this safe profile. It adds 'signed receipt-backed' provenance context, but does not explain verification behavior or response semantics. With annotations covering safety, the description is adequate but not rich.

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

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

The description is a single, compact sentence with no filler. The action verb is front-loaded, and every word contributes to identifying the resource.

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-parameter read tool, the description and annotations cover the core needs: safety, action, and target resource. However, with no output schema and no explanation of what the manifest contains or how 'signed receipt-backed' affects the result, an agent may still have uncertainty about the tool's output.

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

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

The tool accepts zero parameters and the schema is 100% covered, so there are no parameter details the description must clarify. A baseline of 4 is appropriate since parameter documentation is not a burden here.

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

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

The description clearly identifies the action ('Read') and the resource ('signed receipt-backed Wever Commerce Index manifest'), giving it a specific object. However, it does not distinguish itself from sibling get_discovery_manifest, leaving possible confusion between two manifest-like 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?

There is no guidance about when to use this tool versus alternatives such as get_discovery_manifest or get_verified_offer. No when-to-use or when-not-to-use context is provided, which is a significant gap given the overlapping sibling names.

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 this is not read-only and can operate on an open world, so the description's main addition is 'automatically' and 'standing mandate,' which signal an autonomous financial action. It does not disclose further behavioral traits such as side effects, irreversibility, or auth requirements, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no filler words. Every phrase adds some information about the tool's purpose and execution context.

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

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

Despite a high-stakes purchase execution and a complex schema of nested objects, there is no output schema, no parameter guidance, no return-value description, and no mention of required preparation such as obtaining a signed offer or validating the mandate. The description is far too minimal for an agent to safely 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 0%, and all three parameters are opaque objects with additionalProperties: true. The description does not explain what belongs in offer, agentRequest, or paymentPayload, nor how they relate to a signed purchase or standing mandate. This leaves an agent without enough information to construct a valid call.

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 ('execute') and resource ('signed agent purchase'), and clarifies that execution happens automatically within a standing mandate. This distinguishes it from sibling tools like issue_signed_offer or register_owner_mandate.

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

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

The phrase 'within a standing mandate' gives clear context for when this tool should be used: after a mandate exists and a signed purchase is ready. It does not explicitly name alternatives or exclusions, but the context is strong enough for an agent to route correctly.

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 (non-read-only, non-destructive), the description discloses important side effects: validation of an output schema, settlement of seller proceeds and existing fees, and issuance of a network-signed economic receipt. It also reveals the authorization requirement of a seller-signed Ed25519 artifact and the exactly-once guarantee. The phrase 'output schema is validated' is slightly ambiguous, preventing a 5.

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

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

Two sentences, about 40 words, lead with the core action and constraints, then list the consequential outcomes. There is no filler or redundant restatement of schema fields.

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

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

For a side-effectful tool with no output schema, the description covers the essential contract: what is fulfilled, under what conditions, and what happens afterward (settlement, receipt). Parameter names are self-explanatory, and the only real gap is an explicit statement of the return value, though the receipt issuance partially covers that.

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

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

With schema coverage at only 33%, the description compensates by linking fulfillment to the seller-signed artifact, purchaseId to the paid purchase, and idempotencyKey to the 'exactly once' behavior. It does not describe each parameter explicitly, but it adds meaningful context beyond the bare schema types.

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

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

The description clearly states the action ('Fulfill'), the resource ('paid dynamic purchase'), and the key conditions ('exactly once', 'seller-signed Ed25519 artifact'), making it distinct from sibling purchase/execute/recover tools. It conveys a precise post-payment fulfillment step.

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

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

The description implies this tool is used for paid purchases and exactly-once fulfillment, but it does not explicitly state when to use it versus alternatives such as execute_authorized_purchase or recover_commerce_purchase. No direct routing guidance is provided, so the agent must infer usage from context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, establishing a non-mutating operation. The description adds the useful detail that the configuration is credential-free and protocol-specific (MCP or A2A), but doesn't disclose return format, whether it performs network calls, or any other behavioral constraints.

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

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

One sentence with no filler, front-loaded with the verb and then constraints. Every word earns its place.

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

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

For a simple one-parameter tool, the description covers the main purpose and the client constraint, but with no output schema it doesn't describe the shape or format of the returned configuration. The mention of MCP or A2A hints at the output but leaves format details implicit.

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 single 'client' parameter is an enum with self-explanatory values, so the schema largely documents itself. The description reinforces that the client must be supported but adds no explanation of each enum value or expected format; with 0% schema description coverage, it contributes only marginally.

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 ('Generate') with a clear resource ('connection configuration'), and adds meaningful constraints: credential-free, MCP or A2A, supported client. This distinguishes it from sibling tools like get_connection_bundle, which retrieves an existing bundle rather than generating a config.

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 producing a client configuration for a supported agent client, but it doesn't explicitly state when to choose this over alternatives or list exclusions. With siblings like get_connection_bundle and discover_* tools, there is no routing guidance, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. Beyond that, the description adds genuinely new behavioral content: it returns two distinct buckets (available vs. pending) and is restricted to wallets the caller owns, which matters for interpreting results and errors.

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

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

A single front-loaded sentence with no filler; the scope constraint and the two balance categories are stated immediately. Nothing is redundant with the title or the annotations.

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

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

For a one-parameter read tool with a full safety annotation set and no output schema, this covers what the agent needs to select and call it: the currency, the two balance states, and the ownership constraint. It stops short of describing error cases for unowned wallets or whether results are chain-specific, which are the remaining minor gaps.

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

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

Schema description coverage is 0%, so the schema gives only the name and type for walletId. The description partially compensates by implying the identifier must reference a wallet the caller owns and that exactly one wallet is in scope, but it says nothing about format, source, or failure behavior for that 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 names a specific verb (Read) and resource (available and pending USDC) plus scope (one owned wallet), which is far more precise than the bare name 'get_balance'. It does not explicitly contrast itself with near-neighbors like get_wallet or list_transactions, so the sibling differentiation is left implicit.

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

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

Usage is only implied: the reader infers this is the balance-check tool and that it applies to a single owned wallet. There is no statement of when to prefer get_wallet or list_transactions, and no mention of what to do if the wallet is not owned.

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

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

The annotations already declare the operation read-only and non-destructive, and the description adds useful context: the result is scoped to one dynamic purchase and is role-dependent ('buyer or seller view'). It also names the returned content categories, which is meaningful behavior beyond the annotations.

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

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

The description is a single, front-loaded sentence with no filler. It leads with the verb and resource, then compactly lists the returned information.

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

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

For a simple one-parameter read tool with read-only annotations, the description covers scope, role, and the main return categories. Since there is no output schema, listing fulfillment state, signed receipt, and next recovery action helps, though parameter details and sibling routing are still under-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 description coverage is 0%, so the description should compensate for the undocumented purchaseId parameter, but it never mentions the parameter or how to supply it. 'one dynamic purchase' weakly implies that purchaseId selects the purchase, but no explicit parameter semantics are provided.

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

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

The description states a specific operation ('Read') and a specific resource ('one dynamic purchase'), and it enumerates the key outputs: fulfillment state, signed receipt, and next recovery action. It does not explicitly contrast itself with closely related siblings such as get_commerce_receipt or get_purchase_recovery_status, so sibling differentiation is only implicit.

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

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

The phrase 'an authorized buyer or seller view' implies the tool is for an authorized participant needing the composite status of a purchase. However, it gives no explicit when-to-use/when-not-to-use guidance and does not mention alternatives among the many purchase, receipt, and recovery sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds useful selection context by specifying 'existing' and 'owned buyer or seller wallet', but it does not disclose error behavior, authentication expectations, or what happens when the receipt is not found. This is acceptable for a simple read tool but not rich.

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

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

The description is a single focused sentence with no filler or repetition. It front-loads the core action and includes only the essential scope qualifier about owned wallets, so every word earns its place.

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

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

For a simple one-parameter read tool with read-only annotations, the description is mostly adequate. However, with no output schema and no mention of what the response contains or where receiptId comes from, it leaves some gaps for an agent trying to use the tool without 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 0% and the description does not explicitly explain receiptId semantics, format, or how to obtain it. The parameter name is fairly self-explanatory and 'existing' implies the ID must reference an already-created receipt, providing only minimal compensation for the missing schema 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 states a specific verb ('Read'), a specific resource ('existing canonical commerce receipt'), and a clear scope ('involving an owned buyer or seller wallet'). This distinguishes it from sibling tools like verify_economic_receipt or get_commerce_purchase_status by emphasizing retrieval of a canonical receipt rather than verification or status checking.

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 no explicit guidance on when to use this tool versus alternatives. It does not mention when a canonical commerce receipt should be fetched, how to obtain a receiptId, or how this tool differs from other receipt-related or read-only 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?

The readOnlyHint annotation already indicates a safe read operation, so the description does not need to repeat that. It adds a little context with 'signed' and 'universal', but discloses nothing about return format, error behavior, or any operational constraints. This is acceptable for a zero-parameter read-only retrieval but adds only marginal behavioral insight.

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

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

The description is a single concise sentence with no filler. Every word adds specificity to the resource being retrieved, and it is immediately clear what the tool returns. It is appropriately sized for a parameterless retrieval.

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, no output schema, and annotations covering the safety profile, the description is mostly complete for a simple retrieval. The only notable gap is lack of distinction from sibling tools like verify_portable_bundle, which an agent may need for correct tool selection.

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 fully covers parameter semantics and the description has no additional burden. Per the baseline for zero-parameter tools, this scores well.

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 ('Retrieve') and identifies a concrete resource ('the universal signed Wever Pay connection bundle'). It goes beyond the title by adding 'universal signed' and 'Wever Pay', but it does not explicitly distinguish itself from sibling tools such as verify_portable_bundle or generate_client_configuration.

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?

There is no guidance on when to use this tool compared to related sibling tools, nor any mention of alternatives, prerequisites, or context where this bundle should be retrieved. The description only states what it does, not when to choose 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 no-mutation expectation is covered. The description adds the word 'sanitized,' giving some context about data filtering, but does not describe return values or other behavioral details.

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

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

The description is a single concise sentence with no filler. However, phrases like 'sanitized distribution' and 'organic-use status' are dense and slightly ambiguous, which reduces the benefit of the brevity.

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-argument read-only health tool, risk is low, but there is no output schema and the description does not explain what the returned status contains or how 'sanitized' applies. This leaves a moderate gap in the agent's ability to predict the response.

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 coverage is 100%, so the schema fully documents the input surface. The description correctly implies this is an unparameterized read operation, and no additional parameter explanation 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 uses the explicit verb 'Read' and identifies the resource as sanitized distribution, connection, and organic-use status. It conveys the tool's read-only nature, though it does not differentiate it from the similar sibling get_network_metrics.

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

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

No guidance is provided about when to use this tool versus alternatives. While the read-only intent is clear, the description never names conditions, exclusions, or related sibling 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, and the description's 'Read' is consistent with that. The description adds useful content context about the manifest's contents but does not disclose additional behavioral traits such as auth requirements, response format, or any side effects.

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

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

The entire description is one sentence and front-loads the primary action ('Read the signed manifest'). Every phrase earns its place by identifying the resource and its scope without redundant 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?

For a zero-parameter, read-only tool, the description is complete. It tells the agent exactly what will be obtained and the kind of data the manifest connects. No output schema exists, but the enumeration of manifest contents effectively covers what the agent should expect.

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 100% schema description coverage, so there are no parameter details to clarify. Per the baseline for zero-parameter tools, the description is sufficient because no invocation arguments are needed.

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

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

The description names a specific verb ('Read') and a specific resource ('the signed manifest') and enumerates what it contains. It is clearly distinct from sibling tools like get_connection_bundle or get_network_metrics because the 'discovery manifest' is a unique, well-defined resource.

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?

There is no guidance on when to use this tool versus any of its many siblings. The description explains what the manifest is but never states conditions, prerequisites, or alternatives, leaving the agent to infer when this tool should be selected.

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, which match the verb 'Read.' The description adds mild context by saying the history is 'portable' and 'verified' and scoped 'for an agent,' but it does not define what portability/verification mean in the output. This is adequate given the annotation coverage.

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 tight sentence that front-loads the verb and object, with no redundant phrases. It is compact, though slightly under-specified.

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 output schema, the description should indicate what the tool returns, such as the shape or level of detail of 'economic history.' It also does not mention error/authorization conditions or how 'portable' manifests in the response, so an agent cannot fully anticipate the invocation result.

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 0% and there is one agentId parameter. The phrase 'for an agent' only loosely explains that agentId refers to the subject of the history; it does not clarify ID format, whether it must be the caller's ID, or how the value is used. The description does not fully compensate for missing schema documentation.

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 verb 'Read' and names a specific resource, 'portable verified economic history for an agent,' which goes beyond the title and distinguishes the tool from offer/metrics siblings. 'Portable verified' is somewhat opaque but the core purpose is clear.

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

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

No when-to-use or when-not-to-use guidance is provided. The description never contrasts this tool with related read tools such as get_network_metrics, get_verified_offer, or verify_portable_bundle, so an agent cannot decide between them from the description alone.

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 safety profile is known; the second sentence usefully reinforces that no value moves or is credited. It adds the network/asset context (Base mainnet USDC) but says nothing about what happens if the wallet is not owned or what the returned instructions contain.

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-loaded with what is returned and immediately followed by the value-non-moving caveat. No filler or restatement of the tool name.

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

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

For a simple one-parameter read tool the description covers intent and the no-side-effect guarantee, which is most of what an agent needs. With no output schema, however, the shape of the returned "instructions" (text blob vs structured fields, and whether a claim step is included) is left unexplained.

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 single walletId parameter has no schema description (0% coverage), so the description must compensate. "For an owned wallet" does add the ownership precondition, which is genuine meaning beyond the schema, but it does not clarify the identifier format or what an invalid/foreign wallet id causes.

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

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

Uses a specific verb ("Read") with a precise resource ("exact Base mainnet USDC transfer and claim instructions") scoped to "an owned wallet". An agent can distinguish this from the sibling claim_external_deposit by the read-only framing, though the sibling is never named.

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 framing implies this is the step you take before actually transferring or claiming, and "This does not move or credit value" hints at the boundary with claim_external_deposit. No explicit when-to-use/when-not statement or named alternative is given, so the routing is only implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's incremental contribution is the phrase 'public-safe', which hints at accessibility without requiring credentials. However, it does not disclose response shape, aggregations, or potential latency. Given the annotations cover the safety profile, this is adequate but not rich.

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

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

The entire description is one efficient sentence that front-loads the core action and resource, then enumerates metric categories. Every word earns its place and there is no verbosity or redundancy.

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

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

For a simple, zero-parameter read tool with annotations, the description is mostly complete, but it lacks any mention of what the returned metrics look like or how an agent should interpret them. Since there is no output schema, a bit more detail on the return shape would have made this fully self-contained.

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 zero parameters and the schema has no properties, so no parameter explanation is required. The description adds context about the type of data returned, which supports the empty parameter list. This aligns with the baseline for no-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 states the verb 'Read' and the resource 'network metrics', and enumerates specific categories (discovery, commerce, verification, recovery, availability). It is clear and differentiates itself from other getter tools by scoping to aggregate network metrics, though it does not explicitly contrast against 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?

No guidance is given about when to use this tool versus alternatives like get_connection_health or get_discovery_manifest. The description only states what it does, leaving the agent to infer that it is for overall network metrics without any exclusionary or contextual cues.

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 safety profile is covered. The description adds the scoping trait that the operation targets the authenticated participant's canonical account, but it does not disclose other behavioral details such as error conditions or whether the account must exist first.

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 short sentence with no filler, front-loading the action and then specifying the resource. Every word earns its place.

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

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

Given zero parameters, read-only annotations, and no output schema, the description identifies the target resource clearly enough for an agent to call the tool. The only minor gap is that it does not describe the shape or contents of the returned canonical exchange account, but the tool name and description convey the essential purpose.

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?

This tool has no parameters, so the schema fully documents everything an agent needs about inputs. The description reinforces the scope of the returned object but carries no parameter burden. A baseline of 4 is appropriate for a parameterless tool.

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 ('Inspect') and names a concrete resource ('the authenticated participant's canonical exchange account'), so an agent understands what object this tool returns. It does not explicitly contrast itself with siblings like get_wallet or get_balance, but the phrase 'canonical exchange account' helps distinguish it from nearby getters.

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

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

No guidance is provided about when to use this tool versus siblings such as get_balance, get_wallet, or get_participant_registration_requirements. The description implies the usage context ('authenticated participant') but offers no exclusion criteria or alternative 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 declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful environment context — this reads live isolated Base mainnet chain state rather than a cache — but says nothing about freshness, failure behavior when no participant contract exists, or the shape of what is returned. That is a modest addition over the annotations, not a rich one.

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?

It is a single sentence, front-loaded correctly with the verb, but the back half degenerates into a fifteen-item comma list ('policy, credentials, wallets, funding, service admission, commerce, receipts, withdrawal, and recovery rules') that conveys breadth without precision. Several items earn their place; the enumeration as a whole reads as padding rather than 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?

With no input params and no output schema, the description carries the full burden of telling the agent what comes back, and it does try by enumerating the requirement categories. However, it never indicates the return format, whether the answer is a checklist versus a rules document, or what an unregistered participant sees — gaps that matter for a zero-parameter introspection call whose only value is its response.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No misleading parameter implications are introduced.

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

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

States a specific verb and resource: 'Read the active isolated Base mainnet participant contract' plus the registration authority and lifecycle state. It is clearly a requirements/introspection read, distinguishable from siblings like get_sandbox_access_requirements or complete_participant_registration, though the trailing noun list muddies rather than sharpens the 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as get_sandbox_access_requirements (for sandbox) or complete_participant_registration (to actually register). The agent must infer that this is the pre-flight read before registering. The word 'registration' hints at the workflow step, but that is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds an access/eligibility constraint about wallet ownership, which is useful, but it does not explain what happens if ownership is missing, auth requirements, or return 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?

One sentence with no fluff. The core action is front-loaded ('Read a payment') and the qualifying condition is appended without waste.

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

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

For a simple one-parameter read operation with annotations present, the description provides enough to understand basic scope and access. It omits return-value details and doesn't orient the agent among the many sibling get_* tools, but the low complexity keeps the gap moderate.

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 0%, so the description needs to compensate. It clarifies that paymentId refers to a payment in a buyer/seller context, but it does not define the paymentId format, source, or additional semantics beyond the property name and type.

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

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

States a specific verb ('Read') and resource ('a payment'), and adds an eligibility condition (participant owns buyer or seller wallet). This clearly identifies the tool's purpose, though it does not explicitly contrast it with similar siblings such as get_payment_request.

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 clear usage condition: only read payments where the participant owns the buyer or seller wallet. This implies when not to use it, but it does not name alternative tools or explicitly describe exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only nature is covered. The description adds useful behavioral context by limiting reads to requests 'owned by or explicitly addressed to' the participant, which is an authorization constraint beyond the annotations. It does not disclose not-found behavior, error responses, or whether unowned requests are hidden vs. rejected.

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 with no filler or redundant phrasing. Every part, especially the ownership/addressee qualifier, contributes to correct tool selection.

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 one-parameter read-only lookup, the description plus annotations supply the core information needed to select and invoke it: read semantics, authorization scope, and the required ID. It leaves the distinction from get_payment and response/failure behavior implicit, but these are secondary for a simple get-by-ID 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 only documents paymentRequestId as a required string, and the description never mentions this parameter or adds any detail about its format, origin, or relationship to the ownership constraint. With schema_description_coverage at 0%, the description was expected to compensate but does not, though the single parameter's name is self-explanatory.

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 the specific verb 'Read' and identifies the resource 'a payment request,' then adds an ownership/addressee scope that distinguishes it from generic payment reads. It does not explicitly name sibling tools like get_payment, so some differentiation is left to 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?

The ownership/addressee condition gives clear context for when this tool is appropriate: fetching a payment request the authenticated participant is allowed to read. However, it does not state when to prefer related tools like get_payment, request_payment, or send_payment, nor does it include exclusions or when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered. The description adds useful context like 'owned' and 'durable,' but it does not explain what the recovery state contains or whether it represents pending, completed, or failed recovery. 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 a single sentence with no wasted words. The verb and object come first, and the ownership qualifier is placed where it is naturally parseable. Every word earns its place.

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

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

For a simple one-parameter, read-only tool, the description is adequate, and annotations reduce the burden on behavioral disclosure. However, there is no output schema and no explanation of the state values or polling context, and the absence of usage guidance leaves an agent guessing when to call it. It is minimally viable but not fully complete.

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

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

The schema coverage is 0%, so the description must give the parameter meaning. It does so by identifying the parameter as an 'owned Payment Identifier,' which tells the agent what to supply. It does not specify format or validation rules, but for a single string parameter this is sufficient.

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 ('Inspect') and a specific resource ('durable recovery state') scoped to an owned Payment Identifier. This clearly distinguishes it from related siblings like get_commerce_purchase_status and the recover_* actions. An agent can tell what this tool does without opening the schema.

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

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

The description provides no guidance on when to use this tool versus get_commerce_purchase_status, recover_authorized_purchase, or recover_commerce_purchase. It does not mention that it should be used to check recovery progress or what prerequisite conditions apply. The only usage signal comes from the tool name, not the description.

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=false, and destructiveHint=false, so the safety profile is covered structurally. The phrase 'without issuing credentials' reinforces the non-mutating nature, which is mildly useful but mostly redundant with readOnlyHint. Nothing is said about whether requirements vary by network or participant state.

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

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

A single front-loaded sentence with no filler. Every clause carries information and nothing is buried.

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, no-output-schema inspection call, the description is nearly sufficient, and the empty schema plus annotations carry the rest. The only real gap is the unexplained sandbox-versus-mainnet framing, which an agent would need resolved to use the result 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 takes no parameters, so there is no parameter semantics burden; the baseline of 4 applies. The description correctly does not invent arguments.

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 'Read' and the resource 'authentication, standing-mandate, and verification requirements' are specific, but the name says 'sandbox' while the description says 'mainnet', leaving the actual subject ambiguous. It also gives no hint of how it differs from the sibling get_participant_registration_requirements.

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?

There is no statement of when to call this versus alternatives such as get_participant_registration_requirements or the registration/claim flow tools. The agent must infer the entry point from the name alone.

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 safety profile is covered. The description adds modest context—'indexed' and 'verified provenance'—but does not clarify error behavior, not-found handling, or what exactly 'verified provenance' contains, which a no-output-schema tool should disclose more fully.

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 eight-word sentence with no filler, leading with the action and then specifying the target. It is appropriately sized for a tool with one parameter.

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

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

For a simple, one-parameter, read-only tool the core purpose is stated, but without an output schema the description should explain return shape, failure modes, and the meaning of 'verified provenance' more explicitly. The oddity of having zero required parameters is also left unexplained.

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 0%, and the only parameter, serviceId, has no description and is not marked required. The description does not mention the parameter, its format, or why no required fields are declared, so it fails to compensate for the schema's lack of detail.

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

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

The description uses a specific verb, 'Inspect', and a specific object, 'one indexed service and its verified provenance', making it clear this is a single-item read operation. The singular 'one' differentiates it from search_verified_offers, and the 'service' versus 'provider' wording helps separate it from get_verified_provider, though siblings are not named explicitly.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like search_verified_offers or get_verified_provider. The phrase 'one indexed service' only faintly implies a single-lookup use case but gives no prerequisites, exclusions, or routing hints.

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 safety profile is established. The description adds that the tool inspects a signed identity and verified offers, which implies signature verification and offer association, but it does not disclose behaviors like not-found handling, response shape, or failure modes.

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

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

One concise, front-loaded sentence with no filler or repetition. It conveys the essential subject and scope efficiently.

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

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

For a low-complexity, read-only tool with a single obvious parameter, the description is minimally adequate. However, with no output schema and no param documentation, an agent is left without details on what the returned verified offers look like or how providerId should be supplied.

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 0%, so the description must compensate, but it does not directly explain the providerId parameter. The meaning is loosely inferable from the phrase 'provider identity', yet requiredness, format, and source of the ID are left undocumented.

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 'Inspect' and names the resource as 'one signed provider identity' plus 'its verified offers'. It clearly communicates the tool's scope, but does not explicitly differentiate it from siblings like get_verified_offer or search_verified_offers.

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

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

No guidance is provided about when to choose this tool over alternatives such as get_verified_offer or search_verified_offers. The description implies use for inspecting a provider identity, but there are no explicit conditions, exclusions, or alternative 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the ownership scope (wallet owned by the authenticated participant) but does not disclose return shape or failure behavior; this is acceptable given the annotations but adds only modest 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?

A single focused sentence delivers the core purpose and ownership constraint without any wasted words. It is front-loaded and easy to scan.

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

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

For a simple one-parameter read operation with readOnly and destructive annotations, the description is nearly complete. It could mention the return value explicitly, but 'Read one wallet' strongly implies the wallet object is returned, so the gap is minor.

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 0%, so the description carries the burden for explaining the parameter. 'Read one wallet' combined with the parameter name 'walletId' reasonably implies that walletId identifies which wallet to read, though the description never explicitly says so or notes expected format or ownership constraints.

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

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

The description uses a specific verb ('Read') and a precise resource ('one wallet owned by the authenticated participant'), which clearly identifies the operation and object. This distinguishes it from siblings like create_wallet (write) and get_balance (different resource).

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

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

The description implies when to use the tool—when you need a single wallet for the authenticated participant—but it does not state when to avoid it or name alternative getters. There are no exclusions or explicit sibling 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 indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral detail beyond annotations: the ownership proof requirement and the specific status/action categories the tool surfaces, including WAIT_FOR_RECONCILIATION, RETRY_SAME_REQUEST, and RECOVERY_REQUIRED. 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 a single dense sentence with no filler. It front-loads the core action ('Read one withdrawal'), then efficiently packs the output scope, machine-readable actions, and precondition. 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?

For a simple one-parameter read-only tool with no output schema, the description covers the essential input context, the ownership precondition, and the likely return categories. Terms like 'canonical provider-transfer' are somewhat technical but do not block correct invocation, and the machine-readable action values are explicitly enumerated.

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 0%, and the description does not explicitly explain what withdrawalId represents or how it should be formatted. However, the single parameter is self-descriptive from its name, has a simple string type with min/max constraints in the schema, and the description adds the context that a withdrawal is tied to a source wallet. This is minimally adequate but not richly compensating.

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 ('Read') with a specific resource ('one withdrawal') and details exactly what is returned: canonical provider-transfer, ledger status, and machine-readable action. This clearly distinguishes it from siblings like request_withdrawal or get_payment by focusing on withdrawal status and recovery/retry actions.

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 contextual usage guidance by stating the precondition 'after proving ownership of the source wallet,' which tells an agent when the tool is appropriate. It does not explicitly name alternative tools or exclusion cases, so it stops short of a 5.

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

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

The verb 'Inspect' semantically implies a read-only examination, yet readOnlyHint is false — a genuine conflict that could cause an agent to assume the tool is side-effect-free when the annotation says otherwise. The description also fails to disclose what the non-read-only behavior actually is, which is especially puzzling given the required idempotencyKey.

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 tight sentence with the verb front-loaded and zero wasted words. However, the brevity reflects under-specification rather than distillation, since it omits behavioral, parameter, and routing 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?

With no output schema, a non-read-only annotation, an unexplained required idempotencyKey, and 54 siblings, the description leaves too much unknown: return values, side effects, idempotency key purpose, and differentiation from discover/search tools. An agent cannot confidently 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 0%, so the description bears the full burden of explaining serviceId and idempotencyKey, and it explains neither. It never states what idempotencyKey is for, why an 'inspect' operation requires one, or how it should be generated beyond the 8–160 length constraint.

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 names a specific verb ('Inspect') and resource ('existing commerce directory service'), so the basic operation is identifiable. However, the meaning of 'inspect' is opaque — it doesn't say what inspection entails or returns — and nothing in the text distinguishes it from closely related siblings like search_commerce_services, discover_commerce_index, and get_verified_provider.

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

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

No guidance is given on when to use this tool versus the 54 siblings. 'One existing' weakly implies the caller already knows a specific serviceId, but the description never states this precondition, never names discovery/search alternatives, and gives no 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 declare readOnlyHint=false and destructiveHint=false, and the description's 'Issue' aligns with a non-read-only action without claiming destruction. However, the description adds no behavioral detail beyond the annotations: it does not explain what 'official' implies, whether anything is written or published, whether authentication is required, or what happens after issuance. The 'Payment Identifier support' phrase hints at a feature but lacks behavioral substance.

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 with no filler or redundant phrasing. It states the core action, the object, and one notable feature in an efficient structure. Every word earns its place, even though the content is thin in other dimensions.

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 one required parameter, no output schema, and minimal annotations, the description needed to explain what serviceId is and what issuing a signed offer produces or requires. It does neither. The tool is simple in shape, but the description still leaves an agent without enough context to call it confidently or understand the resulting behavior.

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

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

Schema description coverage is 0%, and the description provides no explanation of the sole required parameter 'serviceId'. The agent cannot learn from the description what serviceId refers to, what format is expected, or how it relates to issuing the signed offer. The phrase 'Payment Identifier support' does not compensate for the complete absence of parameter guidance.

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 'Issue' and the resource 'x402 signed offer', and the phrase 'official' adds a meaningful qualifier. It distinguishes itself from verification/search siblings by implying creation/issuance rather than discovery, but it does not explicitly differentiate from related tools like get_verified_offer or search_verified_offers. The terms 'x402' and 'Payment Identifier' are unexplained jargon, slightly reducing 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?

There is no guidance on when to use this tool versus alternatives such as get_verified_offer, search_verified_offers, or execute_authorized_purchase. The description only states what the tool does, not the circumstances or prerequisites for using it. No exclusions, alternatives, or conditions 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?

With readOnlyHint=true and destructiveHint=false already signaling a safe read, the description adds behavioral context: 'bounded' hints at pagination/limit constraints and 'owned wallet' indicates access requirements. It does not fully describe pagination behavior or edge cases, but it does add value beyond the annotations.

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

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

A single, front-loaded sentence with no unnecessary words. The terseness is a positive for conciseness, though the under-specification is penalized in other dimensions.

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?

No output schema and zero parameter descriptions raise the burden on the description, yet it remains minimal and does not explain what 'bounded' means in practice or how cursor and limit interact. It covers the core read operation adequately but leaves gaps for an agent needing detailed pagination semantics.

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 0%, and the description only alludes to walletId via 'one owned wallet'. It provides no additional meaning for limit or cursor, which are left entirely to their names and JSON schema constraints.

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

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

The description uses the specific verb 'Read' and clearly identifies the resource as 'bounded ledger history' scoped to 'one owned wallet'. This differentiates the tool from siblings like get_balance or get_economic_history, even though it does not name them.

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 an owned wallet's bounded ledger history, but gives no explicit when-to-use or when-not-to-use guidance relative to siblings such as get_economic_history. It provides some contextual scope but no exclusions or 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 this is not read-only and not destructive, so the description carries a limited burden. It adds useful behavioral context by stating that 'Exact replay returns the same purchase and payment,' which signals idempotency, and by naming the authority path for the mutating purchase. There is no contradiction with the annotations.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, and the idempotency guarantee is placed second without repeating schema or annotation information. 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?

For a required four-parameter financial mutation with no output schema, the description gives a solid high-level picture but omits important operational context: what 'input' should contain, how the response is structured, how to obtain or identity a 'dynamically admitted service,' and when to prefer this over nearby commerce tools. These gaps make the definition adequate but not complete.

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

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

Schema coverage is low: only 'input' has a real description, and even that is mostly constraint-based. The description compensates partially by semantically mapping 'service' to serviceId, 'owned wallet' to buyerWalletId, and 'exact replay' to idempotencyKey. The 'input' parameter remains semantically unexplained beyond size and depth limits, which prevents a higher score.

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

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

The description opens with a specific action and resource: 'Purchase a dynamically admitted service with an owned wallet.' It adds meaningful context about funding and authority and highlights replay semantics. However, it does not explicitly differentiate this tool from commerce siblings like execute_authorized_purchase or recover_commerce_purchase, so it stops short of full 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?

Usage is implied by the description: the service must be 'dynamically admitted,' the wallet must be 'owned,' and payment must flow through 'existing direct-payment and ledger authority.' Yet there is no explicit statement of when to use this tool versus alternatives, nor any mention of exclusions or prerequisites beyond those hints.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the agent knows this mutates state but is not destructive. The description adds only the vague notion of an 'existing durable recovery path' and does not explain side effects, idempotency, or state transitions. It does not contradict the annotations, but it contributes little 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 one short sentence with no filler, repetitions, or extraneous clauses. It is front-loaded with the action verb 'Resume' and is structurally efficient. However, the brevity comes at the cost of clarity, so it is not a perfect score.

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

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

With no output schema and a single parameter that is undocumented, the description needs to explain what the 'durable recovery path' is, what purchase states qualify, and what success or failure looks like. The annotations cover the safety profile but not these operational details, leaving the description incomplete for an agent deciding whether and how 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?

The input schema has 0% description coverage, and the description never mentions paymentIdentifier or how to supply it. The parameter name is somewhat self-explanatory, but the description adds no semantic value beyond the raw schema and fails to compensate for the lack of schema documentation.

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 names a specific action ('Resume') and resource ('an owned uncertain purchase'), and references a recovery mechanism, so it is not a tautology. However, the phrasing is jargon-heavy and does not clearly explain what makes a purchase 'owned' or 'uncertain' or how this differs from the similar sibling recover_commerce_purchase. The core purpose is mostly clear but under-specified.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as recover_commerce_purchase, get_purchase_recovery_status, or execute_authorized_purchase. The phrase 'owned uncertain purchase' implies a state precondition, but it is not clearly stated, and there are no exclusions or alternative routing hints.

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 a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false), and the description aligns with those by describing a resume/recovery action rather than a new charge. It adds meaningful behavioral context beyond annotations: the operation is idempotent with the same key and avoids a second charge, which is valuable safety information. It does not cover error/status behavior, but given the annotations, this is a modest gap.

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

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

The description is a single, focused sentence with no filler. It front-loads the verb and resource while placing the key safety guarantee ('without creating a second charge') at the end, and 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 no output schema and only minimal annotations, the description gives enough to identify purpose and the no-second-charge behavior, but it does not explain expected return/status, preconditions, or how this differs from recover_authorized_purchase. It is adequate for basic invocation but has meaningful gaps for an agent operating in a complex commerce flow.

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

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

Since schema description coverage is 0%, the description must carry parameter meaning. It connects purchaseId to 'same purchase identity' and idempotencyKey to 'economic idempotency key,' explaining their role in preventing duplicate charges. However, buyerWalletId is never addressed, leaving one of three required parameters without additional semantic guidance beyond its self-evident name.

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 names a specific action ('Resume') and resource ('uncertain buyer authorization' / commerce purchase), and it explains that the recovery uses the same purchase identity and idempotency key without creating a second charge. This is clear and informative, but it does not explicitly distinguish the tool from the similarly named sibling recover_authorized_purchase.

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 establishes a clear when-to-use context: a previously initiated buyer authorization is uncertain and should be resumed rather than recreated. The phrase 'without creating a second charge' also signals a key constraint that prevents the agent from using a new-purchase tool. It does not explicitly list alternatives or a when-not-to-use condition, so it stops short of a 5.

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

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

Annotations already signal destructiveHint=true and readOnlyHint=false, so the mutation and destructive nature are covered. The description adds context about fee-reversal rules and the wallet scope, but does not disclose side effects like irreversibility, partial refund behavior, or idempotency retry implications beyond the annotation.

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

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

The description is a single focused sentence with no filler. The key verb and resource are front-loaded, and every phrase adds some context, making it economically written.

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 this is a destructive mutation with no output schema and likely sibling ambiguity, the description is too thin. It omits prerequisites, idempotency behavior, refund scope, and any indication of what a successful refund returns. The existing annotations and schema do not compensate for these 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?

The input schema has no property descriptions, and the description does not clarify how paymentId, amountMinor, or idempotencyKey map to the refund operation. The property names and constraints carry most of the meaning, but with 0% schema coverage the description should have compensated and did not.

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 ('Refund') and a clear resource ('a sale from the participant's owned seller wallet'), and it adds the mechanism of 'existing fee-reversal rules'. It is clear enough to distinguish the action from a generic payment tool, though it does not explicitly contrast with the similarly named sibling request_commerce_refund.

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

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

No guidance is provided about when to call this tool versus alternatives such as request_commerce_refund, nor are exclusions or preconditions stated. The context signals include many commerce/payment siblings, making selection ambiguous without explicit direction.

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 this is a non-read-only, non-destructive, open-world write, and the description usefully adds that admission is automatic with no seller approval and gated on a list of validation categories. It does not disclose failure behavior, what happens on duplicate serviceId/version, whether a registered service can be amended or must be re-registered under a new version, or whether validation is atomic.

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 opening clause front-loads the action and target, and the total is two sentences with no filler. The middle validation enumeration is a long comma list that reads as a checklist rather than prose, which slightly slows comprehension but carries real information.

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

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

For a high-complexity mutation with a deeply nested required payload and no output schema, the description covers what is checked but not what is returned, whether the service is live immediately in the index, or how retries interact with idempotencyKey. An agent could invoke it but would be guessing about outcomes and safe retry.

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?

At 33% top-level schema coverage, some compensation is needed, and the description does map validation categories onto nested fields (schema, examples, price, endpoint, content hash, seller, payout, fulfillment key). It adds no meaning for idempotencyKey, which is required and whose retry/dedupe semantics are left entirely unexplained.

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 names a specific verb-plus-resource: admit a versioned service into the commerce directory and Commerce Index. It is clearly distinct from read-side siblings like inspect_commerce_service or search_commerce_services, though it never names those siblings to reinforce the boundary.

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

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

Usage is implied rather than stated: you call this when you have a fully-formed service definition to publish, and 'No seller approval is required' signals immediate admission. There are no explicit prerequisites (authenticated participant, ownership of the seller wallet), no exclusion guidance pointing to inspect_commerce_service or the required registration flow, and no note on what to do for an already-registered serviceId.

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 a non-read-only, non-destructive operation, and the description adds useful traits like 'reusable' and 'owner-signed'. However, it does not disclose side effects, overwrite behavior, or what happens after registration.

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 single sentence is efficient, front-loads the action, and contains no filler. It could include more useful detail without becoming bloated, but the current structure is clean and readable.

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 one open object parameter and no output schema, an agent needs more context about accepted mandate structure, return behavior, and side effects. The description covers only the basic intent and leaves critical calling details unspecified.

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

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

The schema provides no property descriptions and coverage is 0%, while the description only says the parameter is an owner-signed mandate. It does not explain required fields, signature format, or valid values for the open additionalProperties 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 names a specific verb ('Register') and resource ('reusable owner-signed mandate'), making the core action clear. It does not explicitly distinguish itself from siblings like revoke_owner_mandate, but the action is sufficiently distinct.

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?

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The sibling revoke_owner_mandate suggests an opposite operation, but the description leaves that selection entirely to inference.

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

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

The annotations already convey that this is a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds one useful behavioral rule: the result is recorded as external-unclassified unless separately verified as organic, which is information not present in the annotations. It does not explain side effects like overwriting or duplicate handling, but the annotation coverage lowers the bar.

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 efficient sentence with no redundant phrases, and it front-loads the verb. However, the over-compressed jargon ('bounded', 'external-unclassified', 'organic') sacrifices clarity, so the structure is concise but not optimally useful.

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 five-parameter tool with no output schema and no parameter descriptions, the description leaves too much implicit. It does not explain what 'bounded' means, what 'organic' verification entails, what values are appropriate for client/stage/success, or what the tool returns, making it incomplete 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 0% and the description mentions none of the five parameters (client, stage, success, notes, reporter). It does not indicate which parameters are required, how success maps to the result, or what values client/stage accept, leaving the agent without any semantic bridge from the description to the schema.

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

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

The description names a specific action ('Record') and a specific object ('a client compatibility result'), so an agent can tell this is a write-oriented reporting tool. However, the modifiers 'bounded' and 'external-unclassified unless separately verified as organic' are domain jargon and do not clearly distinguish it from related verification/reporting siblings, so it falls short of a 5.

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

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

The description provides no guidance about when to use this tool versus alternatives such as verify_portable_bundle, get_verified_offer, or report-related operations. There are no exclusions, prerequisites, or context conditions, so an agent must rely on the tool name alone.

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

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

Annotations only indicate a non-read-only, non-destructive mutation. The description adds meaningful behavioral context: the request is durable, the seller must resolve it, and fee-reversal ledger rules apply. It does not cover authentication or idempotency behavior, but it does not contradict the annotations.

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

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

The description is two focused sentences with no wasted words. It front-loads the core action and uses the second sentence to clarify the downstream resolution process.

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 adequate for tool selection but thin for invocation: it does not describe the success response, idempotency semantics, or how the fee-reversal rules affect the request. With no output schema and no parameter documentation, an agent would need to infer several invocation 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 0%, and the description does not explain the four required parameters. It mentions a 'paid dynamic purchase' as context for purchaseId, but it gives no meaning for amountMinor, reason, or idempotencyKey beyond what their names suggest.

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 ('Create') and identifies the exact resource: a durable buyer refund request for a paid dynamic purchase. It also implicitly distinguishes itself from the seller-side refund_payment tool by explaining who resolves the request.

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

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

The description gives clear context by routing the buyer's request to this tool and the seller's resolution to refund_payment, which is the most relevant sibling. It does not explicitly enumerate all alternatives or state a crisp 'use this when...' rule, so it stops short of a 5.

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

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

Annotations only mark the operation as not read-only, open-world, and non-destructive; the description adds useful context (server-signed, Ed25519, five-minute validity) but does not disclose side effects, rate limits, or what happens to previous challenges. It does not contradict annotations.

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

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

One tightly scoped sentence front-loads the action and resource, then adds the target condition. Every phrase contributes and nothing is redundant.

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

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

The definition is adequate for a basic call because the input schema documents the complex nested object, but there is no output schema and the description does not explain the challenge response structure, encoding, or how the challenge is used with complete_participant_registration. For a high-complexity registration flow, this is a noticeable 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 0% at the top level, so the description must compensate for parameter meaning. It only refers to a 'schema-valid agent.external registration' without naming registrationRequest or explaining how the nested required fields relate to the returned challenge; the schema must do all the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Request a five-minute server-signed Ed25519 challenge.' It further scopes the target to 'schema-valid agent.external registration,' which makes the operation distinct from sibling tools like complete_participant_registration and get_participant_registration_requirements.

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 used during agent external registration ('for any schema-valid agent.external registration') and in a 'cryptographic challenge-response' flow, but it never states when to use it relative to complete_participant_registration, nor does it name alternatives or prerequisites.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that the instrument is USDC and that the amount is bounded, but says nothing about whether funds are held, what happens at expiry, how idempotencyKey deduplicates, or what the caller receives back.

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

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

A single front-loaded sentence with no filler; the defining scope ('bounded', 'one named participant agent') arrives 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?

For a non-read-only tool with five required parameters, no output schema, and zero schema descriptions, one sentence is far too thin. An agent cannot tell how expiry, idempotency, or the wallet/agent identifiers should be populated from this definition alone.

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 0% across six parameters, so the description carries the full burden and largely fails: only buyerAgentId ('one named participant agent') and amountMinor ('bounded') get any gloss. sellerWalletId, idempotencyKey, expiresAt, and description are never explained, and the USDC minor-unit convention behind amountMinor is left implicit.

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 ('Create a bounded USDC request') plus the counterparty model ('payable by one named participant agent'). This clearly separates it from send_payment (push) and get_payment_request (read), though no sibling is named explicitly.

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

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

There is no when-to-use guidance and no named alternative. An agent must infer from the word 'request' alone that this is a pull-style invoice rather than a transfer, and nothing says when to prefer it over send_payment, request_withdrawal, or execute_authorized_purchase.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the agent knows this is an irreversible external write. The description adds real value with the destination lock to the verified EVM-bound address and the 'available' balance restriction. It says nothing about irreversibility specifics, authorization requirements, or what happens on a duplicate submission.

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

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

A single front-loaded sentence with no filler; the scope, asset, and destination constraint come first. It is efficient, though its density leaves key operational details unstated rather than unpacked.

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 destructive, open-world mutation with zero parameter documentation and no output schema, the description is too thin. It omits idempotency behavior, amount units, and how to confirm the withdrawal afterward, all of which an agent needs before invoking it.

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

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

Schema description coverage is 0%, so all three parameters are undocumented in the schema and the description does not compensate. The meaning of amountMinor, the units convention of 'minor', and the role of idempotencyKey are never explained. Only walletId is indirectly implied by 'owned wallet'.

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: transfer USDC out of an owned wallet. It also narrows the destination to the wallet's verified EVM-bound address, which separates it from payment-style siblings like send_payment or request_payment. It does not explicitly name a sibling, so it stops short of a 5.

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

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

There is an implicit usage constraint: the transfer is limited to 'available' funds and to the pre-verified EVM-bound address, so no arbitrary destination can be chosen. However, it never says when to use this versus send_payment, and it does not mention get_withdrawal_status for tracking the result. The context is inferable rather than stated.

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

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

Annotations already mark this as destructive (destructiveHint=true) and not read-only (readOnlyHint=false), so the description does not need to restate that. It adds the important context that the revocation must be 'owner-signed', which is a meaningful precondition beyond the schema. However, it does not disclose effects, reversibility, or any failure modes.

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 with no filler or repetition. It front-loads the action and object. It is appropriately sized for an API that appears to require a single signed revocation object, though it is somewhat terse.

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 destructive, state-changing operation with a nested opaque parameter and no output schema. The description provides only a minimal phrase and lacks critical context such as the shape of a valid revocation, how the owner signature is verified, what happens after revocation, and any side effects. An agent would likely need to inspect other sources to invoke this safely.

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 0%, and the lone 'revocation' parameter is an opaque object with additionalProperties true. The description only calls it 'owner-signed', which adds a small hint, but does not explain the required structure, signature format, or how the object should be constructed. This is insufficient compensation for the lack of 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 states a specific action ('Apply') and resource ('an owner-signed mandate revocation'), making the tool's purpose understandable. It does not explicitly differentiate from the sibling 'register_owner_mandate', but the opposing verbs 'revoke' vs 'register' provide enough distinction.

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

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

No guidance is given about when to use this tool versus alternatives such as register_owner_mandate. There is no mention of prerequisites, required context, or scenarios where revocation is appropriate or inappropriate.

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 destructive, and the description adds meaningful behavior beyond that: revocation is idempotent, requires no operator intervention, and cannot affect another agent's credential. This discloses retry safety and isolation guarantees that are not present in the annotation or schema.

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

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

Two short sentences with no wasted words. The first sentence front-loads the action and the object, and the second adds two critical behavioral facts without redundancy.

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

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

For a two-param destructive tool with no output schema, the description covers purpose, self-service, idempotency, and safety scope well. However, both required parameters remain semantically undocumented in both schema and description, so an agent must infer more than ideal for a correct call.

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 0%, so the description carries the burden for paramerer meaning, but it only indirectly hints at idempotencyKey through the 'idempotent' claim and does not explain credentialId's provenance or format. credentialId is inferable from the phrase 'active participant credential', but idempotencyKey semantics remain largely unexplained.

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 ('Revoke') and a specific resource ('the authenticated agent's active participant credential'), so an agent knows exactly what is acted on. It distinguishes from sibling revoke_owner_mandate by targeting a participant credential and from other revocation flows by explicitly scoping it to the authenticated agent's own credential.

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 establishes a clear self-service use case ('without operator intervention') and implies safe retry via idempotency, which orients an agent toward when this tool is appropriate. It does not explicitly name alternatives or exclusion conditions, but the scope is clear enough that an agent can decide without opening sibling 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 do not declare a read-only hint, and the description only says 'search', leaving side effects ambiguous. The required idempotencyKey suggests possible write-like or retry semantics, but the description does not explain this. 'Bounded filters' is also vague and does not clarify pagination, limits, or result 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 sentence with no filler words or repetition. It is appropriately sized and readable, though the key concept 'bounded filters' is under-specified.

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 six parameters, no output schema, sparse annotations, and many closely related sibling tools, this description is far too thin. It omits filter semantics, the meaning of the required idempotencyKey, result shape, and any differentiation from sibling search/discovery tools.

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

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

Schema description coverage is 0%, so the description must compensate, but it names none of the six parameters. It only says 'bounded filters', which does not explain query, status, network, asset, maxPriceAtomic, or the required idempotencyKey. The description adds almost no semantic value beyond the raw 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 and resource: 'Search the existing commerce directory'. It also implies a scope ('existing') and filter capability ('bounded filters'), which helps distinguish it from the most obvious discovery sibling. However, it does not explicitly differentiate it from related tools like search_verified_offers or inspect_commerce_service.

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?

There is no guidance on when to use this tool versus alternatives such as discover_commerce_index, search_verified_offers, or inspect_commerce_service. The phrase 'bounded filters' hints at use cases involving constrained searches, but no when-to-use or when-not-to-use conditions are 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?

Annotations already cover read-only and non-destructive behavior, so the description should add operational context such as pagination, filter combination semantics, or what 'policy and history' actually dictate. It only restates the domain ('independently verified') without disclosing how results are produced, ordered, or limited. No contradiction with annotations.

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

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

The description is a single sentence with no filler, and the verb and object are front-loaded as 'Filter independently verified offers'. It is efficiently compact, though the brevity sacrifices substantive detail.

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

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

With 9 parameters, no output schema, and only safety annotations provided, the description is too thin to support correct invocation. It does not explain the response shape, default limit behavior, cursor usage, or how 'policy and history' translate into concrete filter arguments.

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 0% for 9 parameters, and the description's phrase 'by policy and history' does not map to any specific parameters like evidenceRequirements, minimumVerifiedCompletions, or network. The agent is left to guess which of the 9 fields correspond to 'policy' vs 'history' and how they interact.

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 ('Filter') with a clear resource ('independently verified offers') and states selection criteria ('by policy and history'). The term 'independently verified' helps position the tool against general offer commerce tools, though it does not explicitly distinguish it from sibling tools like get_verified_offer or discover_assurance_services.

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?

There is no guidance on when to use this tool versus alternatives. It does not mention get_verified_offer for single-offer lookup, discover_assurance_services for broader scanning, or any context triggers or exclusions; an agent must infer usage entirely from the tool name.

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

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

The annotations already establish that this is a non-read-only, non-open-world, non-destructive operation. The description adds useful behavioral context that funds must be available and bounded and may include seller proceeds, but it does not explain idempotency behavior, failure cases, authorization requirements, or whether transfers are reversible.

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

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

The definition is a single tightly packed sentence with the operation and key constraints front-loaded. It is efficient, though the phrase 'including legitimately available seller proceeds' is somewhat dense and could be clearer.

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 financial mutation with six parameters, no parameter descriptions, and no output schema. The description establishes the basic transfer purpose and bounded availability, but it omits critical details such as source versus destination wallet roles, idempotency semantics, amount formatting, and failure behavior.

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

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

Schema description coverage is 0%, so the description must carry the full burden of explaining six parameters. It hints at source-wallet availability and bounded amounts, but never mentions buyerWalletId, sellerWalletId, idempotencyKey, paymentRequestId, description, or the specific 25,000 minor-unit cap.

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: transfer available USDC from a participant-owned wallet using the payment engine. This is clearer than a generic payment operation, but it does not explicitly distinguish the tool from siblings such as request_payment, refund_payment, or execute_authorized_purchase.

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 no explicit when-to-use guidance, prerequisites, or when-not-to-use conditions. An agent must infer that this is the direct payment-sending tool versus request_payment or refund_payment from the name and wording alone.

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 safety profile is clear. The description adds useful context about what is verified (Ed25519 signature and digest) and which receipt categories apply, but it does not disclose what happens on failure, whether the receipt must already be known to the system, or what response the caller receives.

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 with no filler, and the core action is front-loaded. It is reasonably concise, though the dense phrase 'authorized canonical dynamic-commerce or completed-withdrawal' could be clearer without much added length.

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

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

Given the absence of an output schema and two undocumented optional parameters, the description leaves significant gaps: which ID is expected, whether receiptId and withdrawalId are mutually exclusive, and what a successful or failed verification looks like. It provides only the high-level operation without enough operational detail.

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 0%, and the description does not mention receiptId or withdrawalId at all. With two optional parameters and no explanation of how to select one or whether both can be used, the agent receives no value beyond the raw parameter names in the schema. The description must compensate for the low schema coverage but does not.

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

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

The description uses a specific verb 'Verify' and names the exact object: the network Ed25519 signature and digest of a receipt. It identifies the domain (dynamic-commerce or completed-withdrawal receipts), which distinguishes it from generic retrieval tools like get_commerce_receipt or get_withdrawal_status, though the phrase 'authorized canonical' adds jargon and some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as verify_portable_bundle or get_commerce_receipt. It does not state prerequisites, when verification is necessary, or when a different tool should be used instead. Usage is only vaguely implied by the verb 'Verify'.

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 the operation readOnly and non-destructive, and the description adds no concrete behavioral detail beyond the word 'independently'. It does not state what verification checks are performed, what happens on invalid bundles, or whether any external interaction is involved.

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 single sentence is tight and front-loaded with the main action and object. It earns its place, though the brevity is partly the result of under-specification rather than rich, economical detail.

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

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

For a tool with an opaque nested object input and no output schema, the description is too sparse: it does not explain how to build the bundle, what a successful verification returns, or when to call it. It would only be sufficient for an agent already familiar with x402/Wever bundles.

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 one opaque 'bundle' object with no property descriptions and additionalProperties true, yielding 0% schema description coverage. The description merely calls it an artifact bundle, leaving required shape or content unspecified, so the agent lacks the information needed to construct the 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 a specific verb ('verify') and a specific resource ('x402 and Wever assurance artifact bundle'), and 'verify' stands out among sibling tools whose verbs are discover/get/search/execute. It is clear what the tool does, though domain jargon like 'x402' and 'Wever' is unexplained.

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

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

No conditions, prerequisites, or when-to-use guidance are given. The description does not say how this verification differs from related tools like get_verified_offer or search_verified_offers, so an agent cannot reliably choose it over alternatives.

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