Wever Labs Agent Products

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

Annotations already cover read-only, idempotent, and non-destructive traits, so the bar is lower. The description adds genuinely useful context beyond them: no authority or persistence is created, no balance is verified, and existing credentials/signed grants are still required for any real action. It stops short of describing the preview's structure or edge-case 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 purpose is front-loaded, but the same point is restated at least three times ('creates no authority,' 'This adapter grants no authority,' 'grants no authority and never supplies server credentials'). The redundancy consumes budget that could have explained the 13 undocumented parameters.

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 13-parameter, no-output-schema computation tool with 0% schema coverage, the description must be substantially more complete. It explains the trust boundary well but gives no field-level guidance on units, formats, or how the preview is shaped, which are exactly what an agent needs to call it correctly.

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

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

Schema description coverage is 0% across 13 required parameters, so the description must carry parameter meaning. It only groups fields into conceptual families ('scope, budget, usage, expiry and per-action fee limits') without explaining units (minor), the as_of evaluation time, or product-key matching, leaving most semantics 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 states a specific verb-plus-resource: 'Evaluate ... scope, budget, usage, expiry and per-action fee limits' and clarifies the output as a 'would-allow or would-deny preview.' It distinguishes itself as a pure computation ('creates no authority') rather than an authority-granting tool, though it never names the closest sibling (wever_agent-budget-guard) to route the agent 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?

Usage is implied through the operating boundary: use this for a non-binding preview, since it 'creates no authority and verifies no account balance' and 'existing credentials and signed grants remain required for any separate action.' However, there is no explicit when-to-use/when-not statement or named alternative among the many siblings, leaving the agent to infer the boundary.

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

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

The annotations declare destructiveHint=true and readOnlyHint=false, yet the description insists it is a 'sample policy preview, not validated authority' that 'does not ... persist a budget change' and 'grants no authority.' A non-persisting preview is not a destructive operation, so the description contradicts the annotations. The description is also internally inconsistent, calling the backend both unavailable/historical and live.

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 text is bloated with repeated disclaimers ('catalog proxy entry,' 'not a guarantee of backend availability,' 'grants no authority') and is poorly front-loaded, leading with an unavailable-backend caveat rather than the tool's purpose. Several sentences restate the same hedging idea.

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 policy-decision tool with no output schema and 0% parameter coverage, the description should explain the decision response and required inputs, but it mostly enumerates what the tool does NOT do. It surfaces error/availability behavior, which is useful, but the contradictions leave an agent unable to know whether a call has real effect.

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?

Only one parameter ('mode') exists and schema description coverage is 0%, so the description carries the burden — but it only says 'Supply its documented mode, arguments, and required signed authority or grant,' deferring to external documentation. It adds no syntax, format, or value domain for the single 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 definition does name a specific function — returning allow/deny decisions against runs, fees, rails and callback constraints — and distinguishes itself from siblings by stating it does not load an allowance or enforce anything. However, it opens with 'Unavailable historical backend' and 'Sandbox/demo,' which directly conflicts with the later claim that it 'Makes live allow or deny decisions,' leaving the agent unsure what the tool actually is.

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 implied context ('before an agent exceeds permitted runs, fees, rails, or callback destinations'), but no explicit when-to-use versus the ~25 sibling tools such as wever_agent-allowance-console or wever_agent-permission-ledger. No prerequisites or exclusions are stated beyond a generic reference to credentials and grants.

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

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

With annotations present, the description still adds substantial behavioral context beyond them: unit price (0.25 USDC on Base), a quota (10 signed-wallet free calls per rolling 30 days), the required credential/mandate/action-grant context, and an explicit negative boundary (no provider work, callbacks, document retrieval or attestations). Quota, cost, and auth disclosure are exactly the traits annotations do not convey.

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

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

Pricing and access terms are front-loaded ahead of the actual purpose, and several claims are repeated ('grants no authority', 'bounded computation on caller-supplied data', 'uses supplied data only'). The content is relevant but the ordering and redundancy dilute a tool whose core function is one sentence.

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

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

There is no output schema, so the description should carry return-value meaning; it is fair on this point by specifying 'deterministic priorities' and reiterating that no activity is invented. Combined with full schema coverage and rich access/auth detail, an agent has enough to call it correctly, though the output shape remains only loosely described.

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

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

Schema description coverage is 100%, so the schema already documents as_of, services, and queues and their constraints. The description only restates the input domain ('service health and queue observations') without adding syntax or format meaning, so the baseline 3 applies.

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

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

The second sentence states a specific verb and resource: 'Summarize supplied service health and queue observations into deterministic priorities.' That is clear enough to identify the operation. However, it is buried behind pricing and access text, and no sibling among the 24 is named to distinguish it directly.

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 access-path guidance (x402 USDC vs. verified-wallet free tier vs. free /api/mcp or /api/service-resolver) and an operating boundary, which implies usage. But it never states when to choose this tool over the many sibling rails (e.g., sla-rail, budget-guard, trust-scorecard), so routing guidance is only inferred.

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

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

Annotations already declare readOnly=false, destructive=true, openWorld=true, and non-idempotent, and the description adds real context beyond them: sandbox behavior (fixed rationale, submitted order, first-option recommendation), the fact that it does not evaluate supplied constraints, the authority boundary (no credentials supplied, no authority granted), and error handling (non-JSON backends produce tool errors). There is tension between the 'prepares decisions for review / never takes final action' framing and destructiveHint=true, but the tool POSTs an arbitrary product body through a proxy, so the destructive hint is defensible rather than contradicted.

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 content is dense and mostly earns its place, but structure is poor: it opens with the dead statement 'Unavailable historical backend,' then repeats capability framing across the sandbox caveat and the 'Turn messy options...' line before arriving at transport and authority details. Front-loading the capability and boundary while demoting the availability caveat would read far better.

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 still covers what matters for a proxy entry: sandbox fidelity limits, authority and credential requirements, catalog-proxy caveats, and error surfacing. The remaining gap is that the true request contract is delegated entirely to an external 'existing product,' which the description acknowledges rather than hides.

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 is one free-form pass-through parameter with 0% schema description coverage and additionalProperties=true, so the schema offers essentially no semantics on its own. The description compensates only partially: it notes that existing product credentials, signed mandates, and single-use action grants are required and that the product validates its full contract, but it never explains the 'mode' field or the expected body shape.

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 concrete verb+resource: it 'builds a decision-packet template with fixed rationale' and 'ranks options in submitted order, recommending the first option,' enumerating the packet contents (pros, cons, risks, unknowns, constraints, recommendation, human decision point). The opener 'Unavailable historical backend' muddies whether the tool functions at all, and no sibling tool is named for differentiation despite 27 siblings including several decision/authority rails.

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 'Turn messy options into a decision packet' and bounded by the operating boundary ('prepares decisions for review... does not make binding decisions, approve spending, or take final action'), which tells the agent what it must not rely on. However, no alternative sibling is named and no explicit precondition selects this rail over wever_agent-work-order-rail or the other 26 tools.

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

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

With annotations supplied (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), the description does add real context: signed mandates/grant requirements, no server credentials supplied, backend status surfaced, non-JSON backend errors. However, the 'sandbox/demo preview' framing sits awkwardly against destructiveHint=true and idempotentHint=false, blurring what actually mutates.

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?

Six-plus sentences with duplicated and conflicting claims ('unavailable historical backend' / 'sandbox demo preview' / 'create a ... record'), plus boilerplate disclaimers about catalog proxies and backend availability. The core action is buried rather than front-loaded.

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

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

No output schema, a single undocumented parameter, and a large but self-contradictory description leave the agent without a reliable picture of what will happen on invocation. Behavioral disclaimer text is present, but the critical question — does this tool change state or only simulate — is never resolved.

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?

One parameter ('mode') with 0% schema description coverage, and the description adds no meaning beyond the object-level schema note to 'supply its documented mode, arguments, and required signed authority or grant.' Because coverage is very low, the description should compensate for the undocumented parameter 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 oscillates between incompatible framings: 'Unavailable historical backend' and 'Sandbox/demo: previews a release decision' versus 'Create a pending completion authority record that releases only when the required proof package exists.' An agent cannot tell whether this tool previews, records, or releases anything, and the name 'escrow-lite' is undercut by the explicit statement that it creates no enforceable escrow.

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?

'Operating boundary: Creates pay-when-proof-exists authority records for agent work' hints at context but gives no when-to-use/when-not guidance among the ~26 sibling rail/escrow/gateway tools. The only routing signal is generic credentials boilerplate, leaving the agent to guess whether this replaces or complements sibling tools like wever_delegated-authority or wever_payment-authority-inspector.

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?

Despite the annotations already carrying destructive/openWorld flags, the description adds genuinely useful behavioral detail: it discloses that the heuristic does not inspect file contents, verify duplicate content, move or delete files, or perform the cleanup implied by its receipt identifier, and it states that product credentials, signed mandates, and single-use grants are required and that non-JSON/unavailable backends surface as tool errors. The only blemish is tension with destructiveHint=true, since the description insists it never moves or deletes files, though it does frame destructive actions as requiring outside approval.

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 text is bloated and repetitive, with two overlapping purpose statements (one denying capabilities the other asserts), plus long boilerplate about authority, credentials, and proxy status. It is not front-loaded on what the tool does, and the most decision-relevant fact (sandbox filename heuristic) is buried behind 'Unavailable historical backend.'

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-flagged, open-world, no-output-schema tool the description does cover backend availability, error behavior, and authority prerequisites reasonably well. It is incomplete on the input contract (the opaque mode parameter) and on how its claimed capabilities reconcile with its disclaimed ones, so an agent still cannot confidently invoke it.

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

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

Schema description coverage is 0% and the single free-form 'mode' property (maxProperties 64, additionalProperties true) is essentially undocumented. The description says only that signed mandates or grants 'remain required' and never explains what mode values or arguments the POST body expects, leaving the agent without enough 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 does state a concrete mechanism (classifying supplied filenames via invoice/contract substrings and flagging names containing 'copy') and a deliverable (a cleanup review queue). However, it opens by declaring itself an 'Unavailable historical backend,' and the second paragraph claims broader capabilities ('extract document metadata, detect duplicates') that the first paragraph explicitly disclaims, so the actual purpose is muddled rather than crisp. It does not differentiate itself from the many sibling rail 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?

It notes this is a sandbox/demo and a 'catalog proxy entry, not a guarantee of backend availability,' which is weak negative guidance. There is an 'Operating boundary' line saying destructive moves/deletions require outside approval, but no statement of when to choose this tool over the 20+ sibling tools or what preconditions must hold before invoking it.

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

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

The description adds real value beyond the annotations: it names required authority (product credentials, signed mandates, single-use action grants), states that the adapter never supplies server credentials, and documents failure behavior (unavailable or non-JSON backends produce tool errors). But it also asserts "Sandbox/demo... does not create a stored invoice, send a bill, collect payment or record an operator decision" and "This adapter grants no authority," while the annotations declare destructiveHint=true, readOnlyHint=false, and the description elsewhere claims it "Creates invoice-style optional authority." The side-effect profile contradicts the annotations and contradicts itself.

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 most important sentence (what the tool does) is buried in second position behind a dead-end note about an unavailable historical backend, and the remainder is a stack of hedging disclaimers alternating with operational claims. It is not front-loaded and several sentences (proxy disclaimer, sandbox note, availability clause) work against rather than for 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?

There is no output schema, so the description carries the burden of explaining returns; it only hints at a "queued label" that "does not represent a real queue entry" and some binding to rail run/receipt/return package state, without ever describing the actual response. Combined with an undocumented parameter and contradictory statements about whether anything is persisted, the definition is not complete enough for an agent to invoke this open-world, non-idempotent tool with confidence.

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 the single "mode" property, and the description never explains what mode means, what values are accepted, or how arguments/signed authority should be packaged. "POST /api/agent-invoice-rail" adds only the transport, and the object-level schema text defers to an undocumented "product contract." With a low-coverage parameter, the description had to compensate and 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 does contain a usable verb+resource statement ("Create an invoice-style reference for a rail run when instant checkout is not the right payment flow") and it implicitly distinguishes itself from the checkout sibling. However, it is preceded by "Unavailable historical backend" and "Sandbox/demo: prepares an example invoice-reference object for review," which frame the tool as non-functional and conflicting with the mutation framing that follows. An agent must reconcile three different accounts of what this tool is before it can decide anything.

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

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

There is a stated condition of use ("when instant checkout is not the right payment flow") and a mention that credentials, signed mandates and single-use grants are required where applicable, which is genuine routing context. But no alternative sibling is named, and no when-not-to-use case is given beyond the vague "catalog proxy entry, not a guarantee of backend availability" warning.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, but the description adds substantial context they cannot convey: no execution, no quote, no proof verification, no persistence, and that existing product credentials and single-use action grants remain required for any downstream action. It explicitly discloses what is destroyed/omitted (nothing persisted) and its bounded, caller-supplied-data-only scope.

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

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

The purpose is front-loaded, but the description repeats the same non-authority/non-payment boundary three times ('no payment, authority or delivery', 'No authority, payment, execution, proof verification, delivery or persistence', 'grants no authority'). Multiple sentences do not earn their place against that 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 moderately complex tool with a nested required object, 0% schema description coverage, and no output schema, the description should clarify parameters and what 'prepared steps' look like in the response. Instead it exhausts its length on redundant boundary statements and leaves both inputs and return shape opaque.

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 4 required parameters plus a nested, all-required constraints object (max_steps, three include_* booleans). The description says only 'explicit required fields' and never explains mode, agent_id, product_key, or any constraint flag, so it does not compensate for the documentation gap the schema leaves open.

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 first sentence states a specific verb and resource: 'Prepare an ordered sequence of supported planning and computation steps with explicit required fields.' An agent can tell this is a planning/computation tool rather than a payment or execution tool. It is clear but leans on abstract jargon ('supported planning and computation steps') and does not name any sibling it contrasts with.

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

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

It provides a boundary ('No step is executed, no quote obtained, and no payment...') which tells the agent when this tool is NOT the right choice, and notes that credentials/signed grants are required for any separate action. However, no alternative tool is ever named, and there is no positive when-to-use guidance relative to the many sibling rails (work-order-rail, escrow-lite, etc.).

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 destructive/openWorld/non-idempotent, and the description adds real value beyond them: it states it does not authenticate a principal, read a ledger, persist permissions, or grant execution authority, and it discloses error behavior ('unavailable or non-JSON backends produce tool errors'). It leaves some tension with destructiveHint=true unaddressed, but the added boundary detail is substantive.

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 text is long and repetitive, opening with 'Unavailable historical backend' rather than the tool's function, and restating negation ('grants no authority' / 'never supplies server credentials'). Several sentences do earn their place (the operating boundary, the error behavior), but front-loading and redundancy are poor.

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 free-form additionalProperties body, the description must carry the burden; it supplies auth, boundary, and error context but leaves the core purpose and the 'mode' contract ambiguous. It is serviceable but not complete enough for confident 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% for the single 'mode' parameter, so the description must compensate. It partially does ('Supply its documented mode, arguments, and required signed authority or grant') but never enumerates valid modes or the shape of the body, leaving the opaque string under-specified.

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 does name a verb+resource ('previews a permission decision') but immediately undercuts it with 'Unavailable historical backend' and a second, contradictory framing ('Track what an agent is allowed to do...'). It never cleanly distinguishes itself from siblings like wever_agent-allowance-console or wever_delegated-authority, so an agent cannot confidently tell what this does.

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

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

There is no when-to-use / when-not-to-use guidance and no mention of any alternative among the ~26 sibling tools. The only conditional content is about credentials and backend availability, not about tool selection.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true. The description adds useful context such as sandbox/demo status, credential requirements, and JSON error surfacing, but internal contradictions ('prepares a template' vs 'Records the operating terms') and heavy legal boilerplate reduce reliability.

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 bloated with defensive boilerplate and front-loads 'Unavailable historical backend' rather than the tool's purpose. The core action is split across contradictory sentences, so the structure is poor and fails to front-load what an agent needs to invoke the tool correctly.

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 an open-world, non-idempotent, potentially destructive proxy tool with no output schema, the description leaves key gaps: it does not explain the sole 'mode' parameter, does not clarify return behavior, and its conflicting statements make the operating boundary unclear.

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 the sole parameter 'mode', and the description never mentions mode or its semantics. It only vaguely refers to 'supplied values or defaults' and lists operating fields, so it does not compensate for the schema gap.

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 identifies a specific resource (SLA policy template / operating terms for a rail run) and action (prepares/create/records), but multiple conflicting framings ('sandbox/demo template', 'Create an operational promise', 'Records the operating terms') make it hard to state in one sentence what the tool actually does. It also does not distinguish this tool from siblings like wever_agent-work-order-rail or wever_agent-decision-packet-rail.

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 when-to-use, when-not-to-use, or alternative tool guidance is provided. The mention of required credentials and backend status is contextual information, not usage guidance that helps an agent decide between this tool and its many siblings.

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 cover the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), and the description adds substantial context beyond them: sandbox/demo behavior, sample package/receipt identifiers when omitted, no proof verification, no delivery, no authorization granted, never supplying server credentials, and that unavailable or non-JSON backends surface as tool errors. This is unusually rich behavioral disclosure for an adapter entry.

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

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

The description is dense with genuinely distinct information (availability, sandbox semantics, scope, prerequisites, error handling), but it is repetitive: packaging 'completed work for another agent' is stated twice, and it opens with the least actionable sentence ('Unavailable historical backend') rather than the core purpose. It is serviceable but not front-loaded or tight.

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 only one loosely specified parameter, no output schema, and annotations already covering safety, the description supplies the missing context an agent needs: availability caveats, non-capabilities, credential prerequisites, and error behavior. The main residual gap is the absence of guidance on which sibling handoff/receipt tool to pick instead.

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 the single 'mode' parameter is documented only as 'the existing product POST body', so the description must compensate. It partially does by enumerating envelope contents (task summary, return package, exception object, receipt passport, callback target, next action) and by noting mode/arguments and required signed authority or grant, but it never explains the 'mode' value syntax or format, leaving the parameter loosely defined.

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 and resource: it 'assembles a handoff envelope and hash' and packages completed work for another agent, listing concrete contents (task summary, return package, receipt passport, callback target). It also differentiates from siblings by explicitly disclaiming that it does not verify proof, deliver the handoff, or authorize the receiving agent. The confusing opening ('Unavailable historical backend') blurs the purpose slightly but does not obscure it.

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

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

It gives usage context ('Package completed work so another agent can pick it up') and prerequisites ('existing product credentials, signed mandates, and single-use action grants remain required'), plus explicit non-capabilities. However, it never names an alternative sibling tool or states when to choose this over wever_return-package-viewer, wever_receipt-passport, or wever_proof-relay, leaving the when-to-use decision 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 destructive=true, readOnly=false, openWorld=true, idempotent=false. The description goes well beyond them by disclosing that it does not read operational records, that default counts and generated timestamps are not real observations, that credentials/mandates/grants may be required, that it grants no authority, and that unavailable or non-JSON backends produce tool errors. It loses a point because the demo/sandbox framing sits uneasily against a destructive, credential-gated POST.

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 repetitive ('Show proof-based trust signals' vs 'Returns operational trust signals from proof events') and opens with a confusing backend-availability caveat before stating what the tool does. Several hedge sentences about catalog proxying could be compressed; it is over-sized relative to the single free-form 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?

With no output schema, the description carries the return-value burden and does so by listing the proof-based signals it surfaces, plus error behavior for unavailable/non-JSON backends and the auth prerequisites. It is fairly complete for invocation, though the demo-vs-operational ambiguity leaves an agent unsure what data it will actually receive.

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 single 'mode' parameter is essentially undocumented (free-form string, additionalProperties allowed). The description only says to 'Supply its documented mode, arguments, and required signed authority or grant' — it points at the parameter but supplies no format, values, or required-authority detail, so it fails to compensate for the coverage gap.

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 and resource ('Show proof-based trust signals for an agent or provider') and enumerates the signal types (completed runs, receipts, callback success, denied attempts, rails, last seen). It differentiates itself from siblings implicitly by framing value as choosing counterparties 'with facts, not profile claims.' However, the lead-in 'Unavailable historical backend. Sandbox/demo' muddies whether this is an operational tool at all.

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 context is implied ('so agents can choose counterparties with facts'), but there is no explicit when-to-use guidance, no when-not-to-use, and no named alternative among the many trust/proof siblings (wever_proof-inbox, wever_receipt-passport, etc.). The agent must infer selection criteria.

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

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

Beyond the readOnly/idempotent annotations, it discloses substantive behavior: semantic validation is a local deterministic dry run, no request is submitted, no worker assigned, no result delivered, and no persistence or proof verification occurs. That dry-run, no-side-effect profile is real added value, though it is buried in repetition rather than stated once cleanly.

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 same boundary statement is restated three times ('No request is submitted...', 'Prepared computation on caller-supplied data only', 'This current operation is a bounded computation on caller-supplied data'), inflating the text with near-duplicate disclaimers. The strong first sentence is front-loaded, but the remaining sentences do not earn their space.

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?

Behaviorally it is fairly complete for a read-only dry-run tool and there is no output schema to describe, so return values are a non-issue. The gap is elsewhere: with five required, undocumented parameters and no sibling disambiguation, an agent cannot confidently construct a correct call from this description 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 five required parameters, and the description never explains what any of them mean. It alludes to 'caller-supplied data', 'task', and a 'supported computation' (loosely hinting at product_key), but gives no guidance on mode, requested_outcome, requesting_agent_id, or the 16-property task object, so it fails to compensate for the coverage gap.

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 first sentence gives a concrete verb and resource: validate a task and prepare its fixed POST request, so the agent knows this is a dry-run preparation step rather than an execution. However, it never differentiates itself from the many adjacent siblings (agent-work-order-rail, decision-packet-rail, paid-workflow), and the product_key enum even contains 'agent-work-order-rail', which actively muddies its scope.

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

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

Usage is only implied: the description establishes a validation/preparation phase before a separate submission ('Existing credentials... remain required for any separate action'), which hints at when the tool fits in a workflow. It never names an alternative tool or an explicit when-not-to-use condition, so routing against the 25 siblings is left 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?

Annotations only give the coarse profile (not read-only, open-world, not idempotent, not destructive). The description adds genuinely useful context beyond that: it grants no authority, never supplies credentials, performs no provider work/callbacks/document retrieval/attestations, and includes the x402/Base USDC payment terms. This is real behavioral disclosure, though the 'bounded computation on caller-supplied data' claim sits uneasily with openWorldHint=true.

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

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

Front-loading is poor: the first sentence is pricing and 402/x402 mechanics rather than purpose. The prose is repetitive ('bounded computation on caller-supplied data' appears twice), mixes legal disclaimers with operational detail, and includes boundary statements with no operational use for the caller.

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?

Payment, authority, and credential boundaries are reasonably well covered for a tool with no output schema, and the 'prepare, not submit' framing is useful. But an agent still cannot tell what artifact is returned or what the evidence arrays must contain, which are essential for a validation-oriented task.

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 the four required properties, so the description carries the full burden and largely fails it. Only 'Connect recipient' loosely gestures at recipient_id and 'DiligenceOps task' at the constrained service_id; the critical distinction between available_evidence and expected_evidence is never explained.

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 does contain a specific verb+resource: 'Prepare a validated DiligenceOps task for a specific Connect recipient,' which tells an agent what the tool produces. However, this is buried in payment boilerplate and gives no differentiation from the numerous pricing/rail siblings (e.g. wever_agent-work-order-exchange, wever_agent-decision-packet-rail).

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 implies usage as a preparation step ('Submission, recipient permission and execution remain separate steps') and lists prerequisites ('Existing product credentials, signed mandates, and single-use action grants remain required where applicable'). But it never states when to choose this tool over the ~27 sibling rails or when not to use it.

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

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

The description goes well beyond annotations: it discloses that no AP2 signature, principal, merchant, budget, or expiry is verified, that it confers no payment/execution authority, that it never supplies server credentials, and that unavailable or non-JSON backends surface as tool errors. That is unusually rich operational disclosure, though the internal tension between 'check bounded authority' and 'grants no... authority' muddies the picture.

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 text is repetitive and self-contradictory: authority denial is restated three times, while 'check bounded authority' sits against 'grants no... authority'. The lead sentence ('Unavailable historical backend') front-loads a caveat instead of the tool's purpose, and the API endpoint is buried mid-paragraph.

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 proxy POST with no output schema, the description covers prerequisites, authority limits, and error surface, which is most of what an agent needs. It still leaves unclear what a successful call returns (only 'a generated sample receipt' is mentioned) and how the sandbox/demo behavior relates to the documented gateway contract.

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 the single 'mode' property, so the description has to compensate. It adds that the POST body must carry documented mode/arguments plus required signed authority or grants, which meaningful beyond the bare 'mode' enum-less string, but it supplies no format, casing, or valid values for mode itself.

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 concrete resource and action set ('Accept AP2-style mandate references... bind the mandate to rail run receipt proof'), but the opening line 'Unavailable historical backend' and the sandbox framing leave the agent unsure whether this tool actually performs those actions. It also never distinguishes itself from the many adjacent authority/payment siblings (wever_delegated-authority, wever_payment-authority-inspector, wever_unified-agent-checkout).

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 or when-not-to-use guidance and no named alternative, despite a crowded sibling set covering authority checks, mandates, and payment rails. The only contextual line ('Existing product credentials, signed mandates, and single-use action grants remain required where applicable') is a prerequisite, not routing guidance.

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

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

Annotations declare destructiveHint=true and idempotentHint=false, yet the description frames the operation as an inert sandbox that 'does not contact the receiver or verify an acknowledgment, availability or delivery' and merely 'returns an example health response.' A local HTTPS-prefix check destroys nothing, so the description directly contradicts the destructive annotation. This is an annotation contradiction, which caps this dimension at 1.

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 text is long and not front-loaded helpfully ('Unavailable historical backend. Sandbox/demo:' opens on an unrelated status note). Multiple boilerplate sentences about credentials, mandates, adapter authority, and proxy availability restate policy rather than tool behavior, and the redundant health-check/acknowledgment statements dilute the 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?

For a tool with no output schema, an open-world proxy POST, and an undocumented parameter, the description should resolve what the tool actually does and returns. Instead it is verbose, self-contradictory (contacts vs. does not contact the receiver), and leaves the request/response contract and the meaning of 'mode' unresolved.

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 is a single parameter (mode) with 0% schema description coverage, so the description carries the burden. Instead of explaining what 'mode' accepts, it defers with 'The existing product POST body. Supply its documented mode, arguments...' — pointing at documentation the agent does not have. The description adds no usable parameter meaning.

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

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

The description names a specific verb+resource (checks whether a callback URL starts with HTTPS, returns a health response), but it is undercut by two conflicting framings: 'It does not contact the receiver or verify an acknowledgment, availability or delivery' versus 'Check whether a callback receiver is alive, accepts proof payloads, and returns an acknowledgment shape.' The agent cannot tell whether the tool actually probes the receiver or just performs a local HTTPS-prefix check.

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

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

'Validates callback receivers before paid work is delivered so proof can be sent, acknowledged, retried, and audited' supplies a when-to-use context. However, no alternatives are named among the many proof/rail siblings (e.g. wever_proof-inbox, wever_proof-relay), and no when-NOT-to-use is given. Usage is implied rather than prescribed.

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

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

With annotations already declaring destructive=true and readOnlyHint=false, the description adds substantial behavioral context beyond them: nonfinancial single-unit reservation semantics, credential-binding of usage/attribution, idempotency requirements, immutability of records, and explicit non-execution/non-delivery boundaries. This is exactly the value-add structured fields cannot carry.

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?

Front-loaded and information-dense, but repetitive: the non-execution/non-delivery/non-payment boundary is stated at least three times across the paragraph. Several sentences restate the same operating limit, diluting 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?

For a complex multi-mode control-plane tool with no output schema, the description covers the lifecycle, credential requirements, and safety boundaries well. It leaves the eight distinct modes to the schema, which is defensible, but an agent still lacks an at-a-glance mode map.

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?

Reported schema coverage is 0% for the top-level `mode` parameter, but the description conveys the semantic model (issue, approve, consume) without mapping to the specific enum modes. The oneOf branch descriptions in the schema do the per-mode heavy lifting. The description compensates partially but does not enumerate or explain the mode values, so a baseline 3.

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

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

The description states a concrete verb+resource: issue signed mandates and operator-approved action grants, then let credentialed agents consume them to create immutable work-order records. It also cleanly scopes what the tool is NOT (no work execution, delivery, or payment). It does not explicitly differentiate itself from siblings like wever_agent-work-order-rail or wever_ap2-mandate-gateway, so a 4 rather than 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?

Usage context is explicit: operators issue mandates and approve exact action grants with an idempotency key; only the bound credentialed agent may consume a grant; public drafts remain unsigned_dev and cannot execute. It gives required headers per role (X-Wever-Operator-Key, Idempotency-Key, X-Wever-Agent-Key). It stops short of naming alternative sibling tools to route to, so no 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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), the description adds substantive traits: it performs no provider work, callbacks, document retrieval or signed attestations; it grants no authority and never supplies server credentials; and it is a bounded computation on caller-supplied data with USDC/Base settlement. This is unusually rich disclosure of side-effect boundaries for a paid tool.

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

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

The description is lengthy and badly ordered: it opens with pricing ('Paid URL: 1.00 USDC on Base'), defers the actual purpose to mid-paragraph, then repeats payment-route and authority disclaimers multiple times. Several sentences (credential/mandate caveats, 'existing product credentials... remain required where applicable') restate the same hedging without adding actionable 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?

There is no output schema, and the description only loosely sketches the return ('exact matched and missing items') without format detail. It does cover billing model, free tier, and operating boundaries thoroughly, so an agent can understand cost and scope, but the return contract and input format expectations remain thin.

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 property level, so the description must carry semantic weight. It establishes the relationship between the two inputs (expected vs available labels are compared to produce matched and missing sets), which the schema alone does not convey, but it adds no format or constraint guidance beyond that.

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 sentence 'Compare explicit submitted evidence labels and return exact matched and missing items' gives a specific verb, resource, and output, and the follow-up 'does not read or verify document contents' usefully distinguishes it from document-analysis siblings. However, the purpose is buried in the middle of pricing and boundary boilerplate rather than front-loaded, which weakens first-glance identification.

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 mentions free alternative computation paths ('/api/mcp or /api/service-resolver') and an x402 paid settlement route, but this is cost-route guidance, not when-to-use guidance. There is no explicit statement of when to invoke this versus named siblings such as wever_mcp-diligence-rail, only 'where applicable' hedging about credentials and mandates.

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 give hint flags; the description adds real behavioral context beyond them: explicit pricing (0.10 USDC on Base), a free-tier quota (10 signed-wallet calls per rolling 30 days), a pointer to the 402 body for x402 terms, and firm boundary statements ('does not connect to a server or grant authority', 'no provider work, callbacks, document retrieval or signed attestations'). The one gap is that readOnlyHint=false while the text describes a pure caller-supplied computation, leaving the exact state effect (payment) implicit.

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 text is front-loaded with billing terms rather than the task, and repeatedly restates the same authority disclaimer ('This adapter grants no authority', 'does not grant authority', 'grants no authority'). Several sentences duplicate the same operating-boundary point, diluting 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?

For a complex, paid, no-output-schema tool the description covers payment, quotas and operating limits, which is genuinely useful. It stops short, however, of describing what the operation returns (the flagged inventory/annotation findings) or the required shape of the 'tools' payload.

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 single 'tools' array parameter is never explained in the description. The phrase 'submitted MCP tool declarations' hints at the item shape (name/annotations/description) but no format, cardinality limit (16), or required-field detail is conveyed, so the description does not compensate for the coverage gap.

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 operative sentence — 'Inventory submitted MCP tool declarations and flag missing or consequential annotations' — gives a specific verb and resource and is distinguishable from the payment/handoff siblings. However, it is buried under pricing boilerplate, so an agent must dig past the billing preamble to find the actual 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?

The description names access paths ('/api/mcp or /api/service-resolver', 'POST /api/mcp-diligence-rail') and pricing tiers, but never states when to use this tool versus alternatives like wever_diligenceops-paid-run or wever_payment-authority-inspector. No exclusions, no scenario guidance.

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

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

The description does add genuine context beyond annotations (sandbox/demo nature, that unavailable/non-JSON backends raise tool errors, that backend status is surfaced). However, it repeatedly reassures that it 'grants no authority', 'never supplies server credentials' and 'does not verify', which reads as a harmless read-only inspection while annotations declare readOnlyHint=false and destructiveHint=true. This mismatch between the reassuring framing and the declared side-effect profile is the main defect.

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 opens with a caveat ('Unavailable historical backend') instead of the action, and repeats the 'grants no authority / no server credentials' disclaimer across multiple sentences. The return-field list and the no-verification disclaimer are also in tension, adding noise rather than front-loaded 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?

With no output schema, the description does enumerate expected return fields (verified, pending, approved, allowed rail, amount, expiration, run permission) and covers error/backend behavior, which is useful. But for a POST proxy with an opaque schema and destructive annotations, the contract is still insufficiently pinned down and internally inconsistent.

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 single 'mode' property is an open-ended, additionalProperties body with no enum or format detail. The description says 'Take a payment reference', which does not map onto the documented 'mode' parameter, so it neither compensates for the coverage gap nor clarifies how to populate the body.

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 does state a core action ('classifies payment-reference text', 'Inspects a submitted optional authority reference'), but it buries that under hedging and self-contradiction (first says it does not verify payment/expiry/mandate, then lists 'verified' and 'expiration' as outputs). It never distinguishes itself from siblings like wever_ap2-mandate-gateway or wever_delegated-authority, so an agent cannot confidently route to it.

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 versus the many sibling authority/payment tools, and no prerequisites or exclusions are stated. The closest thing is the vague 'Operating boundary' sentence, which describes what it returns rather than when to pick it. An agent is left to guess the trigger conditions.

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

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

The description does add real context beyond annotations (credentials/mandates required, no authority granted, backend status and JSON errors surfaced), which is valuable. However, it frames the operation as a read ('Read a single view', 'Shows proof events') while annotations declare readOnlyHint=false and destructiveHint=true, and it simultaneously claims it 'does not read or write an inbox'. This is an annotation contradiction.

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

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

The text is disorganized and repetitive, listing the same proof-event categories three times (completed runs, receipts, callbacks, exceptions, handoffs) and burying the contradictory sandbox disclaimer ahead of any usable statement of purpose. It is not front-loaded around the tool's actual function.

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 write tool with no output schema and an undocumented parameter, the description should clarify what gets affected and how to invoke it. Instead it leaves the destructive semantics unaddressed and surrounds the call contract with caveats and contradictions, so an agent cannot safely call 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% for the single 'mode' parameter, and the tool description never explains what 'mode' accepts or how to populate it. It only hints that an existing product POST body with 'documented mode, arguments, and required signed authority' is expected, leaving the parameter effectively 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 opens by declaring the backend unavailable and the tool a sandbox that 'generates five example proof-event categories' and 'does not read or write an inbox', then immediately says 'Read a single view of completed runs...' and 'Shows proof events from live agent work.' These statements conflict, so an agent cannot tell what the tool actually does. No sibling tool is named or differentiated.

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

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

There is no explicit guidance on when to use this tool versus the many sibling proof/receipt/relay tools (wever_proof-relay, wever_receipt-passport, wever_callback-health-monitor). The 'operating boundary' text describes scope but not selection conditions or exclusions.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, but the description adds genuinely new behavioral facts: references and supplied hashes remain unverified, no destination is contacted, nothing is persisted, and existing credentials/signed grants are still required. The 'supplied hashes remain unverified' disclosure is important context an agent cannot derive from the annotations alone.

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

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

The purpose is front-loaded, but the body repeats the same disclaimer multiple times ('No authority, payment, execution... delivery or persistence' then 'no destination is contacted... nothing is delivered or persisted'). Roughly half the text is redundant boundary boilerplate that does not advance understanding.

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

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

For a complex nested schema with no output schema and 0% parameter coverage, the description covers behavioral boundaries exhaustively but under-serves the parameter and return-shape side. It conveys the general output (a prepared envelope plus binding digest) without detailing the destination kinds or reference envelope structure the agent must construct.

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 four required parameters, so the description must carry the burden, but it only loosely gestures at concepts ('reference envelope', 'source/destination binding digest', 'references and supplied hashes'). It never explains the mode const, the agent-vs-callback destination oneOf, or the maxItems/reference format constraints, leaving the nested schema largely undecoded.

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 set: 'Prepare a reference envelope and deterministic source/destination binding digest.' An agent understands it produces an envelope plus a binding digest. It does not differentiate itself from related siblings such as wever_proof-inbox or wever_receipt-passport, 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?

Usage is implied through the operating boundary ('Prepared computation on caller-supplied data only') — the tool is a preparation step, not a delivery step, and takes caller-supplied data. However, no alternative tool is named and no explicit condition ('use this when...') is given, leaving the agent to infer routing among the many wever_ siblings.

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

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

Adds substantial context beyond the annotations: it declares the output is generated sample data ('not measured production results'), names required auth material (credentials, signed mandates, single-use grants), asserts the adapter 'grants no authority and never supplies server credentials', and specifies error behavior for unavailable/non-JSON backends. There is mild tension with destructiveHint=true/openWorldHint=true given 'No external rail work runs', but the network POST makes an open-world hint plausible and the text does not directly assert the opposite of 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 first sentence is well front-loaded, but the text repeats itself — 'Test PacketOps and DiligenceOps with sample data, then start a agent run with the same rail shape' and 'Lets agents test rail shape with sample data, then move directly into paid PacketOps or DiligenceOps runs' say the same thing twice. It also contains a typo ('a agent run') and mixes purpose, auth, and error notes without clear ordering.

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 an opaque proxy endpoint with an open schema and no output schema, the description covers sandbox semantics, required authority, and failure modes, which is what an agent needs to call it safely. It stops short of describing the shape of the generated package or how to feed the output into a paid run.

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?

Only one free-form parameter at 0% schema description coverage, so the description must compensate. It hints at the required contract indirectly ('signed mandates, and single-use action grants remain required where applicable'), but the formal explanation of the POST body lives in the schema's own top-level description rather than in the tool description, so the added value is limited.

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 concrete verb+resource: a sandbox that 'generates an example rail package, receipt and transcript locally' with 'No external rail work runs.' That distinguishes it from the paid-run siblings (PacketOps/DiligenceOps). The jargon 'rail package' is only meaningful through context, keeping it 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?

'Test PacketOps and DiligenceOps with sample data, then start a agent run with the same rail shape' plus the explicit operating boundary ('then move directly into paid PacketOps or DiligenceOps runs when ready') gives clear when-to-use and points at the alternative tools. No explicit when-not-to-use statement, so 4 rather than 5.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, but the description adds substantial context beyond them: the backend is a sandbox/demo that fabricates a sample run, output 'is not evidence of production execution,' existing credentials and signed mandates are still required, and unavailable/non-JSON backends surface as tool errors. That is meaningful disclosure of behavior and side effects an annotation cannot express.

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

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

Four paragraphs restate the same idea twice ('Create a short, portable proof object' vs 'Creates a portable proof passport'). It is front-loaded with the confusing 'Unavailable historical backend' line rather than the primary purpose, and the boilerplate about credentials/authority dilutes the 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?

For a destructive, open-world tool with no output schema, the description does cover credentials, error surfacing, and the sandbox limitation. What it never resolves is the tension between promising a verifiable proof object and disclaiming that nothing is retrieved or verified, so the agent cannot fully predict the outcome of a 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% and the single 'mode' property is effectively an opaque free-form POST body with additionalProperties allowed. The description partially compensates by telling the agent to 'Supply its documented mode, arguments, and required signed authority or grant,' but the parameter remains unspecified with no example or format, so the agent is left guessing at valid values.

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 does give a specific verb and resource ('Create a short, portable proof object for a completed rail run'), which sets it apart from the many sibling rail tools. However, it immediately undercuts itself by declaring an 'Unavailable historical backend' and saying it 'does not retrieve or verify completed work or supplied proof,' leaving the agent unsure whether it produces anything real. The core purpose lands but is muddied by the sandbox framing.

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 supplies a clear temporal cue ('Use it after a completed run') and names the artifacts it touches (receipt, return package, callback, transcript linkage). No alternative sibling is named, and no when-not-to-use condition is given, so routing between this and adjacent proof/return-package tools is left 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 description states the tool 'Reads completed return packages ... without changing the source rail output,' which is read-only semantics, yet the annotations declare readOnlyHint=false and destructiveHint=true. The two signals directly conflict, so despite otherwise rich disclosure (auth requirements, error surfacing, sandbox nature), this is an annotation contradiction.

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

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

The most important caveat (unavailable/sandbox backend) is front-loaded, which is good, but the body is verbose and repetitive, restating that it grants no authority and supplies no credentials. Several boundary sentences overlap and could be consolidated.

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

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

For a complex proxy tool this covers a lot: auth prerequisites, backend/error behavior, sandbox limitations, and the absence of an output schema is mitigated by describing the JSON/page shape. However, the parameter contract is left opaque and the read-only vs destructive conflict leaves an agent unsure how to call it 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 single 'mode' property is undocumented. The description defers parameter meaning to external docs ('Supply its documented mode, arguments, and required signed authority or grant') rather than explaining accepted values or formats, so it only partially compensates for the coverage gap.

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: it renders a generated example return package and receipt status, and presents rail proof facts as JSON to agents and a page to humans. The lead line about an 'Unavailable historical backend' and the explicit 'does not retrieve a stored package' caveat clarify scope. It does not differentiate this viewer from siblings like wever_receipt-passport or wever_proof-inbox, which prevents 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 no explicit when-to-use guidance and no named alternative among the many sibling rail/proof tools. The only routing-adjacent statement is a negative one ('does not retrieve a stored package or establish that work completed'), which is a capability disclaimer rather than selection 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 readOnly=true, idempotent=true, closed-world, non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: no authority grant, no payment, no execution, no proof verification, no delivery, no persistence, and that server credentials are never supplied. This is substantive, though the 'grants no authority' claim is restated three times rather than extended.

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?

Purpose is front-loaded in the first sentence, which is good, but the boundary statements repeat the same idea ('no authority', 'grants no authority', 'existing credentials remain required') across three sentences. The repetition pads length without adding new information, though the overall size remains moderate and no sentence is entirely wasted.

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

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

The description is thorough about the operational boundary, which is genuinely needed for a checkout-adjacent tool, and no output schema exists so return values need not be explained. What it omits is anything about the six required parameters and, for a tool whose name says 'checkout', what the computation actually returns or how the result should be used downstream. Adequate but with 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?

Schema description coverage is 0% across 6 required parameters, including a nested items array and two nullable reference fields, so the description carries the full burden. It hints at items (via 'itemize'), USD currency, and caller-supplied amounts, but gives no meaning for mode, agent_id, payment_reference, or allowance_reference — notably why those two references are required in the schema yet described as unnecessary for this operation. It does not compensate for the coverage gap.

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: 'Itemize and total caller-supplied USD estimates for supported computations.' It also distinguishes itself from adjacent concepts by explicitly denying being a provider quote, checkout session, payment request or authority grant, which separates it from siblings like wever_x402-payment-gateway or wever_ap2-mandate-gateway. It stops short of naming which sibling to use instead, so it is clear but not fully sibling-routed.

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 'Operating boundary: Prepared computation on caller-supplied data only' line implies this is the tool for pre-computation of estimates, and the note that credentials/grants are required for any separate action implies this tool itself is not the action step. However, there is no explicit 'use this when X, use sibling Y when Z' guidance, which matters given the large set of adjacent payment/authority 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 description does add real behavioral context beyond the annotations: it states the tool does not verify payments, prevent replay, settle funds, or authorize access, that unlock state is simulated, that no credentials are supplied, and that non-JSON/unavailable backends produce tool errors. However these claims are tangled with contradictory framing ("Unavailable historical backend" vs. "Backend status and JSON errors are surfaced") and sit uneasily beside destructiveHint=true, so the agent is left unsure which effects are real.

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?

Leads with a confusing status fragment ("Unavailable historical backend") instead of the tool's function, then repeats the same idea twice in adjacent paragraphs ("Accept x402-style optional authority references, bind them to a requested rail..." and "Operating boundary: Accepts x402-style optional authority references..."). Dense boilerplate with hedging that dilutes rather than front-loads the core action.

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

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

There is no output schema, and the description usefully names the returned fields (challenge, binding, replay-protection, unlock, receipt, callback) plus the error behavior, which is more than most definitions in this family. But it omits any description of the request body shape and routes, and the sandbox-versus-real ambiguity leaves the agent unable to judge consequences of a 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?

One parameter with 0% schema description coverage, and the schema is a free-form object (additionalProperties: true, maxProperties: 64) whose only named field, "mode," is undocumented. The description gestures at inputs ("optional authority references," "supplied or default payment header," "supply its documented mode, arguments, and required signed authority or grant") but never explains what those look like, so it does not compensate for the coverage gap.

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 does contain a concrete verb+resource ("builds an example x402 challenge and binding hash from a supplied or default payment header"), but it is immediately hedged with "Unavailable historical backend," "Sandbox/demo," "catalog proxy entry," and "not a guarantee of backend availability." The agent cannot tell whether this is a real payment gateway, a demo stub, or a proxy, and nothing distinguishes it from overlapping siblings like wever_ap2-mandate-gateway, wever_payment-authority-inspector, or wever_rail-playground.

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 statement of when to choose this tool versus the other 26 payment/rail siblings, and no exclusions. The only near-guidance is a prerequisite clause ("Existing product credentials, signed mandates, and single-use action grants remain required where applicable"), which is conditional and vague. An agent has no routing signal.

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