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

The description discloses key behaviors beyond the readOnlyHint annotation: it returns 'last known balance' from a credential store, performs no network request, and explains the condition for the 'stale' flag (updated more than 5 minutes ago). This adds meaningful context that annotations alone don't provide.

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

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

Two concise sentences deliver all essential information: the action, the caching behavior, and the staleness rule. Every sentence earns its place with no redundancy or filler.

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

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

For a simple one-parameter tool with no output schema, the description explains the return concept (balance and stale flag) sufficiently well. It stops short of detailing the full response structure or edge cases (e.g., no cached value), but given the simplicity, this is a minor gap.

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

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

Schema description coverage is 100% and the only parameter 'origin' already has a clear description with a URI format and example. The description adds no additional parameter-specific meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Check cached credit balance for a server.' It distinguishes this tool from siblings by emphasizing that it uses a cached value and makes no network request, which sets it apart from other l402 tools like l402-fetch or l402-pay.

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

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

The description clearly implies when to use this tool: when you want a fast, cached balance check without network overhead. However, it doesn't explicitly name alternatives or state when not to use it, so it lacks explicit exclusions that would merit a 5.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true, so the safety profile is handled. The description adds the mode behavior and the toll-booth restriction, but it does not clarify side effects of a purchase, such as spending funds, irreversibility, or error/response 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?

Three short sentences front-load the purpose and immediately state the key branching behavior. Minor redundancy exists between 'from a toll-booth server' and 'Only works with toll-booth servers,' but overall it is 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?

For a three-parameter tool with no nested objects, core invocation is covered: required URL, optional method, optional amountSats, and the toll-booth constraint. However, there is no output schema and the description does not say what a successful purchase or tier-discovery response contains, which is a notable gap for a financial operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The narrative about omitting/providing amountSats adds a little clarity, but it largely repeats the schema's description of amountSats and does not enrich method or url beyond what the schema already says.

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

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

The description opens with a specific action ('Buy credits') and identifies the resource ('a toll-booth server') and a differentiator ('volume discounts'). It distinguishes this from sibling payment tools by restricting it to toll-booth servers, though it never names a sibling 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?

Provides explicit branching guidance: omit amountSats to discover tiers, provide amountSats to buy a specific tier, and only works with toll-booth servers. This gives clear when-to-use context, but it does not compare against siblings such as l402-pay or l402-discover, so it falls just short of a 5.

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

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

Annotations declare readOnlyHint=true, which the description aligns with by using 'Introspect'. The description adds value beyond the annotation by revealing what kind of read-only data is returned: wallet configuration, spending limits, and credential count. No hidden mutation or side effects are suggested.

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

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

Two tight sentences with no filler. The first sentence states exactly what the tool does and its outputs; the second gives actionable usage guidance. Every clause earns its place.

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

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

With no parameters and no output schema, the description sufficiently explains what the tool returns at a categorical level. It could be more explicit about output format or whether any setup is required, but for a zero-input introspection tool it is adequately complete for an agent to call it correctly.

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

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

The tool has zero parameters, so there is no schema burden to compensate for. The description accurately describes the tool's no-input introspection behavior, and the baseline of 4 is appropriate since no parameter documentation is needed.

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

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

Description uses specific verb 'Introspect' with resource 'payment capabilities' and enumerates concrete outputs: wallets configured, spending limits, stored credential count. The instruction to call this first also distinguishes it from sibling tools like l402-pay or l402-fetch, making its role clear.

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

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

It explicitly says 'Call this first to understand what payment methods are available', giving clear context for when to invoke it. It does not explicitly list alternatives or when not to use it, but the sequencing guidance and broad discovery purpose sufficiently differentiate it from 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?

The readOnlyHint annotation already marks it safe, and the description adds genuinely useful behavior: balances are cached and possibly stale, and the lastUsed timestamp is the way to judge freshness. This is beyond the annotation and gives the agent a realistic expectation of data reliability. No contradiction exists.

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

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

Two tight sentences front-load the action and displayed fields, then add the stale-balance caveat. Every sentence carries operational value, and no redundant filler is present.

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

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

For a zero-parameter, read-only listing tool, this description is complete: it says what is listed, what fields are shown, and warns about cache freshness. The lack of an output schema is mitigated by naming the visible fields, and there are no params/options whose behavior would need elaboration.

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

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

The input schema is empty (0 parameters), so there are no parameter semantics for the description to enrich. With schema coverage at 100%, the description cannot add anything parameter-related, and the baseline of 4 applies.

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

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

States the action ('List all stored L402 credentials') and the resource/scope precisely, then names the displayed fields (origin, cached credit balance, server type). This distinguishes it from siblings like l402-store-token or l402-balance by focusing on stored credentials rather than operations or current balance.

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: an agent can infer this is for inspecting stored credentials, and the 'cached/may be stale' caveat hints that l402-balance might be the alternative for fresh numbers. However, it never explicitly states when to prefer this tool or names an alternative, so it stops short of clear 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?

With readOnlyHint=true and openWorldHint=true already present, the description adds meaningful behavioral details: no payment is committed, the challenge is cached for later reuse, and responses include pricing and payment-method information. It does not contradict the annotations and gives enough context for safe usage.

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

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

The description is compact and front-loaded: the core action appears first, followed by return-value highlights and the caching behavior. Every sentence earns its place without fluff or repetition.

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

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

For a simple probe tool with one required parameter and no output schema, the description covers what the tool returns, when to use it, and the relevant caching side effect. It does not specify failure behavior or non-L402 endpoints, but those are minor gaps given the overall clarity.

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

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

Schema coverage is 100%, so the schema already documents both parameters and their defaults. The description reinforces that 'url' is the endpoint being probed but adds little about 'method' beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Probe') and resource ('endpoint') and states the purpose: discover L402 pricing without payment. It also names concrete outputs (cost in sats, payment methods, credit tiers) and distinguishes itself from l402-pay by mentioning challenge caching. This makes the tool's role clear even among many siblings.

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

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

The description clearly implies the tool is a pre-payment discovery step: 'without committing to payment' and 'a subsequent l402-pay can reuse it' provide strong context for when to use it. It does not explicitly enumerate exclusions or alternative tools, but the intended workflow is evident.

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 say openWorldHint/destructiveHint; the description adds the financial behavior (spend limits, MAX_AUTO_PAY_SATS capping), credential reuse, untrusted-content marking of responses, refusal of unsupported paymentFlow before network/wallet access, and the experimental x402 handling. These are material traits beyond the annotations.

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

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

Front-loads the core action and payment condition, then layers edge cases. Parenthetical protocol lists and conditionals make it dense, but nearly every clause carries decision-relevant information.

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

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

For a 10-param, no-output-schema tool, it covers return behavior in both branches (402 with price/paymentHash, x402 payment details), the preview prerequisite, and spend safeguards. Nothing an agent needs to call it safely is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter semantics: maxCostSats 'lowers MAX_AUTO_PAY_SATS for this call; never raises it', and implies the autoPay/price interaction. It stops short of explaining pubkey/txHash mechanics that the schema itself covers.

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+resource ('Fetch a URL, paying its HTTP 402 challenge') with the exact protocols supported. It also distinguishes itself from siblings by naming l402-pay and l402-fetch-preview with the conditions that select each, so an agent can route without opening schemas.

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

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

Explicit when-to-use branches: autoPay true pays within budget, autoPay false returns the 402 for user decision, l402-pay pays afterwards, and widget hosts must call l402-fetch-preview first. Exclusions are stated, not implied.

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

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

Annotations already declare readOnlyHint=true, so the description's claim of 'without spending any sats' reinforces but adds specific meaning (no financial side effect). It also describes what the tool returns (cost, protocol, payment method) and the intended UI usage, which goes beyond the annotation. However, it does not mention potential errors or connection issues, a minor gap given the annotations cover safety.

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

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

Two sentences, front-loaded with the primary purpose, and no filler. The usage guidance is embedded efficiently. Every clause earns its place.

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

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

For a preview tool with read-only annotations, the description covers the core purpose, return data, and usage context. It does not describe the exact output schema (since none exists), but that is compensated by stating the key fields. Minor gaps like error handling or authentication requirements are not addressed, but given the simplicity, it is largely complete.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds no parameter-specific usage detail beyond what the schema provides. It does not explain how to format arrays or headers, but the schema already covers that. Thus, baseline 3 is appropriate.

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

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

The description states a specific verb ('Preview'), resource ('payment requirements for a URL'), and outcome ('without spending any sats'). It clearly distinguishes from l402-fetch by positioning itself as a pre-check. The purpose is unambiguous and actionable.

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

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

Explicitly instructs to 'Use this before l402-fetch' and gives the condition (to give the user a chance to approve or cancel payment). Also mentions the widget host context. This directly routes the agent to the correct tool and tells when not to use the alternative.

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 openWorldHint=true, so the description doesn't need to restate that this spends funds. It adds real behavioral context beyond them: credential persistence so the next l402-fetch succeeds, a 120s settlement poll for human wallets, and an approval gate for foreign invoices. It stops short of describing failure/timeout outcomes.

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

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

Three sentences, all load-bearing: the primary action and its goal first, then human-wallet timing, then the edge-case invoice rule. No filler, no repetition of schema text.

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

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

For a 5-parameter tool with no output schema, it covers the full workflow handoff (fetch/discover → pay → credential stored → fetch succeeds) and the human-approval veto. Missing only what happens on poll timeout or payment failure, which the agent would want before retrying.

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

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

Schema description coverage is 100%, so the baseline is 3. The description still adds meaning by tying paymentHash to the source tools, clarifying the invoice-vs-paymentHash branch, and noting the approval requirement for non-challenge invoices, which is parameter-selecting behavior rather than restatement.

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

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

States a specific verb+resource (pay an L402 challenge and store the credential) and identifies exactly which siblings produce the input (l402-fetch, l402-discover). An agent can distinguish this from l402-redeem-cashu or l402-store-token without opening any schema.

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

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

Gives explicit routing ('a challenge that l402-fetch or l402-discover returned, by its paymentHash'), timing ('call it straight after showing the payment URL'), and an exclusion ('an invoice that did not come from such a challenge is paid only if the human approves it'). This is close to a complete decision procedure.

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 provide openWorldHint=true and destructiveHint=false, but the description adds substantial behavioral detail: auto-pay to the service is paused while unresolved, settled payments store credentials when possible, failed payments are cleared, and abandon requires human approval. This is far beyond what the annotations alone convey.

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

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

The description is a single dense paragraph with the core purpose front-loaded, followed by invocation modes and parameter-specific behavior. Every sentence earns its place; there is no filler or repetition of schema details.

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

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

Given three optional parameters, no output schema, and significant side effects, the description covers invocation modes, resolution outcomes, credential storage, and the human-in-the-loop requirement. It does not describe the return format of listing unresolved payments, but this is a minor gap for an agent already given the schema.

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

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

Schema coverage is 100%, but the description adds real meaning beyond the schema: paymentHash triggers an NWC lookup_invoice or Cashu mint lookup, preimage must hash to the payment hash to settle, and abandon requires human confirmation. It enriches each parameter with behavioral context rather than repeating schema text.

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

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

The description states a specific verb and resource: 'Resolve a payment whose outcome is unknown' and immediately distinguishes the two main modes: listing unresolved payments versus resolving a specific one. This clearly separates it from siblings like l402-pay or l402-fetch by focusing on reconciliation of uncertain payments.

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

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

The description gives explicit call patterns: call with no arguments to list, with paymentHash to query the wallet, with preimage to settle, or with abandon for human confirmation. It does not explicitly name sibling alternatives or state when not to use the tool, but the usage conditions are clear enough for an agent.

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

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

Beyond the annotations, the description reveals an important behavioral trait: it automatically handles the two-step flow of creating an invoice then redeeming the token. It also clarifies that the tool only works against toll-booth servers. It does not detail the destructive consumption of the Cashu token, but destructiveHint=true already signals the mutation risk.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no fluff. The only minor inefficiency is repeating the toll-booth-server constraint in both the first and final sentences.

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

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

For a two-parameter tool with no output schema, the description covers the main selection criteria, the target server type, and the internal two-step flow. It does not specify return values or post-redemption behavior, but the annotations and simple parameter surface make this a minor gap rather than a blocking one.

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

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

The input schema already documents both parameters with 100% coverage, so the baseline is 3. The description adds contextual flow details but no additional parameter-level meaning beyond what the schema already provides.

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

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

The description opens with a specific verb and resource: 'Redeem Cashu ecash tokens directly on a toll-booth server', and adds a clear differentiator by noting it avoids the Lightning round-trip. It also closes with a scope limitation ('Only works with toll-booth servers'), making it easy to distinguish from siblings like l402-pay or l402-fetch.

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 useful context for when to choose this tool: it is for direct Cashu redemption on toll-booth servers, avoids Lightning, and automates the two-step flow. It does not explicitly name alternative sibling tools or state 'use X instead', but the toll-booth-only constraint and direct-vs-Lightning framing provide adequate 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 readOnlyHint and openWorldHint, but the description adds meaningful behavior beyond them: it discloses the privacy model (topic filters go to relays, whereas payment method and query text are matched locally) and flags announcement text as untrusted data. It stops short of describing result shape or relay failure/timeout behavior, keeping it out of the top tier.

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

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

Five tight sentences, no filler, with the core purpose front-loaded before the caveats. Slightly dense with several distinct warnings stacked together, but each sentence carries 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?

With no output schema, the description carries more burden, and it largely meets it by sketching what results are ('descriptive results') and the trust posture of announcement text. It doesn't describe pagination, result fields, or behavior on relay timeout, which are the remaining gaps for a multi-relay query tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description genuinely adds semantics by explaining WHERE matching happens per parameter: topics are pushed to the relays while paymentMethod and query text are evaluated locally. That distinction is not in the schema and directly affects how an agent should combine filters.

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 (Search) and resource (Nostr relays) constrained to kind 31402 paid API / storage announcements, which is precise enough to distinguish it from generic search tools. It does not, however, name or contrast against the closest siblings (l402-discover, l402-service-directory), so the differentiation is inferable rather than explicit.

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 useful boundary conditions ('No storage node or wallet is contacted', 'Wildbloom checkout cannot be bought with l402-fetch/pay'), which imply when this tool is and isn't appropriate. But it never states when to choose this over sibling discovery tools like l402-discover or l402-service-directory, leaving the core routing decision 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 already declare readOnlyHint=true and openWorldHint=true, covering safety and open-world behavior. The description adds value by revealing that the tool is interactive ('Opens an interactive directory') and that it internally calls l402-search, which implies a wrapper behavior and potential user-interface side effects. This is beyond the annotations and is not contradictory.

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

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

The description is two sentences with zero waste. The primary purpose is front-loaded ('Browse and search paid API services'), and the additional details about the interactive directory and internal call are placed efficiently. Every sentence earns its place.

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

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

Given the tool has no parameters and annotations already convey read-only and open-world behavior, the description provides sufficient context to understand what the tool does. However, it does not describe the return format or what 'interactive' means precisely, and it does not differentiate from similar siblings. These gaps are minor for a zero-parameter tool, so a 4 is appropriate.

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

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

The tool has zero parameters, so there is nothing to document. Per the instructions, a zero-parameter tool gets a baseline of 4 since the schema coverage is trivially 100% and no description compensation is needed. The description does not need to add 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 states a clear verb and resource: 'Browse and search paid API services.' It adds context by mentioning it opens an interactive directory of L402/x402 services discovered on Nostr and that it calls l402-search internally. However, it does not explicitly differentiate itself from siblings like l402-search or l402-discover, which could be confused as alternatives, so it stops short of a 5.

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

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

The description implies usage context by saying it opens an interactive directory and calls l402-search internally, suggesting it is a higher-level wrapper for interactive browsing. But it provides no explicit 'when to use' vs 'when not to use' guidance, nor does it name any sibling tools as alternatives. The usage conditions are 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 adds behavioral context beyond the idempotentHint annotation by stating the token is persistently 'stored as a credential' and that this makes subsequent l402-fetch calls authenticated. It does not contradict the annotations; the readOnlyHint=false aligns with the mutation implied by 'Store.'

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

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

The description is two sentences with no wasted words. It front-loads the core action, then provides the usage trigger and downstream benefit, making it easy for an agent to parse quickly.

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

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

For a simple two-parameter store operation, the description covers what the token is, where it comes from, and why it matters. It does not describe the return value or error behavior, but given the simple side-effect model and the idempotentHint annotation, this is a minor gap rather than a blocking omission.

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

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

The input schema already has 100% coverage with clear descriptions for both parameters, including the token format 'macaroon:preimage'. The description reinforces the token format and purpose but does not add meaningfully beyond the schema's parameter descriptions.

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

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

The description states a specific verb and resource: 'Store an L402 token (macaroon:preimage) obtained from a payment page.' It also clarifies the token's role as a stored credential for authenticating subsequent l402-fetch calls, making the purpose unambiguous and distinguishable from sibling tools like l402-credentials or l402-fetch.

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 an explicit trigger: 'Use this when a user pastes back a token from a toll-booth payment page.' It also explains the downstream effect by noting the token is stored for later l402-fetch authentication, but it does not explicitly mention alternatives or cases where this tool should not be used.

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

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

The readOnlyHint-only annotation is complemented by the description's added behavioral detail that this 'opens an interactive dashboard' rather than merely returning data. This is important context for an agent deciding whether the tool is suitable for automated workflows. No contradiction with the read-only annotation exists.

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

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

Two sentences carry the full message with no filler: the first states the action and subject, the second adds the specific dashboard contents. The information is front-loaded and every phrase earns its place.

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

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

For a zero-parameter, read-only dashboard tool, the description is largely complete: it names the visible elements (NWC connection, Cashu balance, auto-pay limit, credential list) and signals that the result is an interactive interface. A bit more context about how this relates to the sibling balance/credential tools would round it out.

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

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

The tool has zero parameters, and the schema's property list is empty, so there is no parameter documentation burden on the description. The description correctly implies no inputs are required by framing the tool as a view-only dashboard.

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

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

The description uses a specific verb ('View') and resource ('wallet status, balances, and stored credentials'), making the core purpose clear. It also lists concrete dashboard contents, but it does not explicitly distinguish itself from siblings like l402-balance or l402-credentials.

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

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

The description implies usage for a consolidated wallet overview ('View wallet status, balances, and stored credentials') and clearly indicates an interactive dashboard. However, it does not state when to prefer this tool over the sibling balance, credential, or config tools, and provides no exclusions.

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