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

No annotations are provided, so the description carries the full behavioral burden and largely drops it. It does not say whether duplicate URLs are rejected, whether the endpoint is verified/challenged, what secret or signing key (if any) is returned, whether the call is idempotent, or what permissions are needed for a mutating operation.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly the cause of the missing behavioral detail rather than optimal density.

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

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

For a one-parameter create call the description is minimally sufficient to invoke the tool. But with no annotations and no output schema, it leaves open what the call returns (webhook ID, signing secret) and how the registered endpoint is meant to be used — meaningful gaps for a registration/mutation tool in a payment API.

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% for the single `url` parameter, so the baseline is 3. The description adds only a hint of payload context ("payment notifications") beyond the schema's "webhook URL to call when events occur" — no format, validation, or HTTPS constraints are added.

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?

Specific verb + resource: "Register a new webhook callback endpoint" says exactly what is created, and "to receive payment notifications" adds the reason. It is distinguishable from remove_webhook and list_webhooks by implication, but never names them or states the contrast 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 only implied: an agent can infer this is the create-side counterpart to list_webhooks/remove_webhook. There is no statement of when to prefer this over subscribe_invoice_status (push webhooks vs. subscription streams), nor any prerequisites, exclusions, or limits on how many webhooks may exist.

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 no annotations provided, the description alone must disclose behavioral traits. It states the action but does not mention reversibility, confirmation, scope limitations (e.g., only current session vs. all sessions), or what happens to individual subscription feeds. The description is too terse to convey the operational impact.

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

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

The description is a single, well-structured sentence that front-loads the verb and object. It contains no extraneous words and is perfectly sized for the tool's simplicity.

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

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

The tool is simple with no parameters, but with no output schema and no annotation, the description provides only the basic action. Missing details such as return value, whether it confirms cancellation, and the exact scope of 'active real-time subscriptions' leave the agent with unanswered questions for a mutating 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?

The tool has zero parameters, and the schema covers everything (100%). According to the rubric, a baseline of 4 applies for zero-parameter tools. The description adds no parameter details because none exist, which 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 ('Cancel') and resource ('all active real-time subscriptions'), clearly distinguishing it from the sibling tool 'cancel_subscription' which targets a single subscription. The scope is unambiguous and the purpose is immediately understandable.

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 as a bulk cancellation action, contrasted with the singular 'cancel_subscription' sibling, but it does not explicitly state when to choose this over alternatives or mention any prerequisites or side effects. The guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and a condition ('unpaid') without mentioning side effects, reversibility, error conditions, or permissions. For a state-changing operation, this is a significant gap in transparency.

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

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

The description is a single, front-loaded sentence with no filler words. It efficiently communicates the tool's purpose without unnecessary detail, making it appropriately concise.

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

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

Given the low complexity of the tool (2 fully described parameters, no output schema), the description is minimally sufficient to convey the core action. However, as a mutation tool with no annotations, it would benefit from additional context about what 'cancel' actually does (e.g., whether it fails on paid invoices, what happens afterward), which prevents a higher score.

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 provides descriptions for both parameters (wallet_id and payment_hash), covering 100% of parameters. The description text adds no additional parameter-specific meaning, so it does not improve upon the schema's baseline coverage.

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

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

The description 'Cancel an unpaid Lightning invoice' clearly identifies the action (cancel) and the resource (Lightning invoice), with a specific qualifier (unpaid) that distinguishes it from sibling tools like create_invoice, pay_invoice, or cancel_subscription. This is a specific verb+resource pairing.

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

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

The description implies the tool is for canceling an invoice that has not been paid, which gives a clear context. However, it does not explicitly state when to use it versus alternatives or mention any exclusions, so guidance is only implied rather than explicit.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure, but it only states the action without explaining side effects, required permissions, idempotency, or error behavior. It adds no behavioral context beyond the literal action.

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 clear sentence of five words, front-loaded with the verb, containing no redundant or extraneous information.

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

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

For a simple one-parameter tool, the description is adequate but has gaps: no usage guidance, no behavioral transparency, and no explicit distinction from cancel_all_subscriptions. Without annotations or an output schema, more context would help the agent fully understand the tool's 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?

The schema fully documents subscription_id with the description 'The subscription ID to cancel' and 100% coverage. The tool description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'cancel' and identifies the resource as 'an active real-time subscription', indicating a single subscription. This clearly distinguishes it from sibling tools like subscribe_* and cancel_all_subscriptions, which cancels all subscriptions.

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

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

The description provides no guidance on when to use this tool versus alternatives such as cancel_all_subscriptions or list_subscriptions. No context, prerequisites, or exclusions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not specify the return format (e.g., boolean), whether the check is case-insensitive, or any error conditions. This leaves the agent uncertain about the tool's output and 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 description is a single, front-loaded sentence with no wasted words. It directly communicates the essential purpose without redundancy.

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

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

For a simple one-parameter tool, the description covers the basic purpose but lacks details on return values and behavioral nuances. Given no output schema and no annotations, the agent may not know what to expect from the tool's response.

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

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

The schema already fully describes the only parameter ('username') with 'The username to check', and the description adds no additional meaning beyond that. Baseline 3 applies since schema coverage is 100%.

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

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

The description clearly states the tool's function: checking if a Blink username is available. It uses a specific verb ('check') and resource ('username availability'), distinguishing it from sibling tools like 'set_username' and 'lookup_user_wallet'.

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

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

The description implies its use as a pre-check before setting a username but does not explicitly state when to use it versus alternatives. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden and delivers little. It doesn't say whether the returned estimate is a live rate or a cached/sampled one, whether it reflects a spread, whether it refreshes, or whether any call is idempotent/free. "Estimation" implies a non-binding quote, but that is inference, not disclosure.

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

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

A single nine-word sentence with no filler and no buried clauses. It is efficient, though the brevity here is partly under-specification rather than disciplined editing.

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?

Two required params, no annotations, and no output schema: the description is the only place to explain what comes back (a rate? a converted amount? both?) and it says nothing. For a conversion tool whose whole value is the returned figure, that is a material 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?

Schema description coverage is 100%: `amount` is documented as major units (not cents) and `currency` as a fiat code, both better than the tool description manages. The description adds no parameter meaning at all, so the baseline 3 applies. It notably fails to resolve which parameter's denomination the output is expressed in.

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

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

The verb and resource are clear ("Get currency conversion estimation between fiat and Bitcoin"), which distinguishes it from siblings like send_onchain or create_invoice. However, the direction of the conversion is genuinely ambiguous: with params `amount` and `currency` (a fiat code) and no stated source/target, an agent cannot tell whether it passes a fiat amount and receives BTC or vice versa. The sibling get_realtime_price is closely related and not named.

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

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

No when-to-use guidance, no prerequisites, and no alternatives are named. Notably, the agent gets no help distinguishing this from get_realtime_price or get_price_history, which are the obvious competing calls for price/rate information. The word "estimation" hints at a quote-like result but the description never says when to prefer 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?

No annotations are provided, so the description carries the full behavioral burden. It says nothing about what the call returns (invoice/payment request), that invoices expire, whether it requires an existing wallet, or that status must be polled/subscribed separately via the sibling tools.

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

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

Two short sentences, front-loaded with the action and scope. Slight redundancy in restating the satoshi unit already covered by the schema, but no padding.

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 mutation tool with no annotations and no output schema, the description leaves too much out: no return value, no expiry semantics beyond the schema default, and no routing among the three create_invoice variants.

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

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

Schema coverage is 100%, so baseline is 3. The description's unit note ('Amount is in satoshis') duplicates the schema's own 'Amount in satoshis to receive', and it adds nothing about memo, expires_in, or external_id.

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 (create a Lightning invoice) plus the key scope constraint: a fixed amount received into a BTC wallet. The phrase 'specific amount' implicitly separates it from create_invoice_no_amount, but the sibling is never named, so differentiation relies on the agent inferring 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?

Usage is only implied: a fixed satoshi amount for a BTC wallet suggests 'use this when the amount is known and denominated in BTC.' It never mentions create_invoice_usd or create_invoice_no_amount, nor any prerequisites (wallet existence, expiry behavior), which are exactly the forks an agent faces here.

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 no annotations, the description carries the full burden. It does disclose the key behavioral trait (amount is intentionally unset and payer-determined), but says nothing about default expiration, whether a bolt11 request is returned, or any wallet/permission prerequisites for creating the invoice.

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

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

Two short sentences, zero filler, with the defining constraint ('without a specified amount') front-loaded before the explanatory clause.

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 schema is fully self-documenting and there is no output schema to explain, but for a state-creating tool with zero annotations the description leaves the agent guessing about the returned artifact and expiration defaults, which matters for wiring the invoice into a payment flow.

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

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

Schema description coverage is 100%, so all four parameters including the required wallet_id and expires_in are already documented in the schema. The description adds no syntax, units, or default values beyond that, 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?

Specific verb + resource ('Create a Lightning invoice') with a qualifying scope ('without a specified amount / open invoice'), which effectively separates it from create_invoice and create_invoice_usd. It stops short of naming those siblings explicitly, so the differentiation is inferred rather than stated.

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

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

The phrase 'The payer can choose how much to send' implies the use case (open/tip-style invoice), but there is no explicit when-to-use vs. when-not, and no named alternative such as create_invoice or create_invoice_usd for fixed-amount flows.

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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose a genuinely non-obvious trait — the invoice is denominated in sats but credited as USD — which is valuable. However it omits whether the invoice is single-use, what the fixed/implied expiry behavior is (schema only mentions a default), and, with no output schema, what the caller gets back (bolt11 payment request, payment hash, expiry timestamp).

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

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

Two short sentences with zero filler, and the denomination/credit distinction — the most important fact — is front-loaded.

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

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

For a mutating, money-moving tool with no annotations and no output schema, the description covers the currency semantics well but leaves the agent guessing about the return payload and about prerequisites (must wallet_id be a USD wallet?). Adequate but with clear gaps given the tool's stakes.

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 all five parameters (including the USD-wallet constraint on wallet_id and the 5-minute USD expiry default) are already documented. The description reinforces that amount is in USD cents, matching the schema, but adds no new semantics. 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?

States a specific verb+resource with the distinguishing qualifier: a Lightning invoice denominated in USD cents (Stablesats), settled in satoshis. This implicitly separates it from create_invoice and create_invoice_no_amount, but it never names those siblings, so the agent must infer that plain create_invoice is the BTC-denominated variant.

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 by the currency qualifier — an agent can infer 'use this when you want to receive USD' but there is no explicit when-to-use, no exclusion of create_invoice/create_invoice_no_amount, and no note about required wallet type (a USD wallet_id is required per schema, but the description never says what happens with a BTC wallet).

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 no annotations, the description carries the full burden of behavioral disclosure. It only states that a new address is generated, without mentioning output format, address reuse, or whether the previously generated address remains valid. Key behavioral details are omitted.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the core action and purpose.

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

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

For a tool with one required parameter and a clear action, the description plus schema are minimally adequate. However, the lack of an output schema and any mention of the return value or behavior changes leaves gaps for an agent selecting and invoking the tool.

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

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

Schema description coverage is 100% and the parameter 'wallet_id' is well-described in the schema. The tool description adds no additional semantic meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Generate') and resource ('new on-chain Bitcoin address to receive funds'), clearly stating the action and distinguishing it from siblings like get_current_onchain_address, which retrieves an existing address.

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

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

The description implies the use case (receiving funds) but does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions. It is adequate as a basic purpose statement but lacks explicit usage guidance compared to 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It doesn't state whether the operation is read-only, requires authentication, or has side effects. The word 'estimate' suggests non-mutating, but the description provides no specifics about rate limits, permissions, or other behavioral traits.

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

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

The description is a single, concise sentence that clearly conveys the tool's purpose without unnecessary words or repetition. It earns its place with zero waste.

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

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

The tool is simple with two fully documented parameters, but since there is no output schema, the description should explain what the returned fee estimate looks like (e.g., units, format). It also doesn't clarify how this differs from estimate_lightning_fee_no_amount, leaving a small gap in contextual completeness.

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

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

Schema description coverage is 100%, with both parameters (wallet_id and payment_request) already documented in the input schema. The description itself adds no additional parameter meaning beyond what the schema provides, matching the baseline for high schema coverage.

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

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

The description clearly states the tool estimates Lightning network fees for paying an invoice, with a specific verb ('estimate') and resource ('Lightning network fee'). It distinguishes itself from the sibling tool estimate_lightning_fee_no_amount by specifying 'for paying an invoice', implying it handles invoices with an amount.

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

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

The description implies when to use the tool (before paying an invoice, to estimate the fee) but provides no explicit guidance on when not to use it or how it compares to estimate_lightning_fee_no_amount. There are no alternative tool names or exclusions mentioned, so usage context is only implied.

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

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

No annotations exist, so the description carries the full burden. 'Estimate' implies a read-only calculation with no funds moved, but the description never confirms there are no side effects, no wallet mutation, or what the estimate is derived from. It provides minimal behavioral context beyond the verb.

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

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

A single, front-loaded sentence with no filler; every word contributes to scope. It is efficient but extremely terse, leaving no room for the clarifying detail that would help an agent.

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 3-required-parameter estimation tool with no annotations and no output schema, the description is thin. It doesn't explain the required amount-vs-no-amount relationship or the shape of the returned estimate, both of which an agent would benefit from.

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 all three parameters (amount, wallet_id, payment_request) are already documented in the schema. The description adds no parameter-level detail — notably it does not explain why 'amount' is required when the invoice has no amount.

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 ('Estimate') and resource ('Lightning network fee') plus the qualifying condition 'open (no-amount) invoice', which implicitly separates it from the sibling estimate_lightning_fee. It stops short of naming that sibling, so the distinction must be inferred.

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 'open (no-amount) invoice' qualifier implies when this tool applies, but no alternative is named and no exclusion or prerequisite is stated. An agent must guess that estimate_lightning_fee covers amount-bearing invoices.

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?

No annotations are provided, so the description carries the full behavioral burden. It implies a non-sending estimate but does not state that the result is non-binding, whether authentication or wallet permissions are required, whether funds are reserved, or how speed/network conditions affect the estimate.

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

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

The description is a single front-loaded sentence with no filler. Its brevity is efficient as a conciseness measure, even though missing details are captured in other dimensions.

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

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

There is no output schema and no annotations, yet the description does not explain what the fee estimate returns, such as amount, currency, or validity period. For a four-parameter estimation tool, this leaves meaningful contextual 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 100%, with all four parameters documented and speed including an enum and default. The description adds no additional parameter semantics beyond what the schema already provides, so the 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 and resource: estimate the on-chain transaction fee for sending Bitcoin. It also distinguishes itself from Lightning-fee tools through 'on-chain', though it does not explicitly differentiate from estimate_onchain_fee_usd.

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: call this when estimating the fee for an on-chain Bitcoin send. It does not explicitly say when to use this versus estimate_lightning_fee or estimate_onchain_fee_usd, nor does it state prerequisites 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that this is an estimate but does not clarify that it is read-only, that it does not send funds, what permissions or preconditions are required, or whether the quote expires.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the operation and scope.

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 four-parameter fee estimator with complete schema coverage, the description identifies the operation adequately. However, with no annotations and no output schema, it leaves gaps around the return unit, quote validity, and explicit sibling-tool selection.

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

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

Schema description coverage is 100%, so all four parameters are already documented, including amount in cents, Bitcoin address, USD wallet ID, and the FAST/MEDIUM/SLOW speed enum. The description adds only that the source wallet is a USD wallet, which reinforces wallet_id but adds no further parameter semantics.

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

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

The description uses a specific verb ('Estimate'), resource ('on-chain transaction fee'), and scope ('from USD wallet'). This distinguishes it from sibling estimators such as estimate_onchain_fee and estimate_lightning_fee.

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

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

The description implies it is used when estimating a fee before sending from a USD wallet, but it gives no explicit when/when-not guidance or alternative routing. The agent must infer that this is not the Lightning fee estimator and not the generic on-chain estimator.

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?

No annotations are provided, so the description must disclose behavioral traits on its own. It mentions 'current user' (implying authentication context) and lists the data categories, but it does not explicitly state that this is a read-only operation, whether it requires specific authorization scopes, or any rate-limit or side-effect considerations. The description carries only a minimal burden for a simple getter, but still lacks meaningful behavioral disclosure beyond the verb 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 description is a single, front-loaded sentence that efficiently conveys the tool's purpose without waste. It includes just enough detail (wallets, balances, settings) to clarify the scope, and every word earns its place.

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

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

For a simple, parameterless read tool with no output schema, the description is largely complete: it identifies the subject (current user) and the major data categories returned. It could go further by stating that this is an aggregate or high-level endpoint, especially given the many sibling tools, but the current text is sufficient for most use cases.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty object). Per the rubric, 0 params merits a baseline of 4; the description correctly avoids inventing parameter details and focuses on the returned data scope.

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

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

The description clearly states the tool's function: 'Get the current user account information including wallets, balances, and settings.' It uses a specific verb ('Get') and resource ('account information'), and the 'including' clause distinguishes it from narrower sibling tools like get_wallets or get_wallet_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?

The phrase 'current user account information' implies this is for a high-level account snapshot, and the inclusion of wallets, balances, and settings suggests use when multiple account facets are needed. However, there is no explicit guidance about when to choose this over siblings like get_wallets or get_account_limits, nor any stated 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?

No annotations are provided, so the description carries the full burden. 'Get' strongly implies a read-only operation, and the listed categories add specificity. However, it does not disclose potential nuances such as whether limits are current cumulative usage or maximum thresholds, any authentication requirements, or response structure.

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

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

The description is a single, concise sentence that starts with the action verb and immediately communicates the resource and scope. No redundant words or filler; it is optimally structured for quick 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?

With zero parameters and no output schema, the tool's complexity is low. The description adequately states what the tool does. It could further specify the meaning of 'limits' (e.g., daily vs. lifetime) or mention that no input is required, but for a simple getter it is near-complete.

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

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

The tool has zero parameters, and the input schema is empty with 100% coverage vacuously. Per the guidelines, 0 params earns a baseline of 4. The description correctly adds no parameter information since none exist.

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

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

The description uses a specific verb 'Get' with a clear resource 'account limits' and explicitly enumerates the scope (withdrawals, internal sends, currency conversion). This distinguishes it from siblings like get_account_info, which likely provides broader account information.

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 when account limits are needed, but it does not explicitly state when to prefer this tool over alternatives like get_account_info, nor does it provide exclusions or prerequisites. The context is clear but not explicit about differentiating from overlapping 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?

With no annotations, the description carries the full burden. It clearly states the operation is a read ('Get') and scopes are tied to the current API key, but it does not explicitly disclose whether the operation is side-effect-free, requires authentication, or may return an empty list. Some additional context would be helpful.

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

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

The description is a single, concise sentence that directly states the tool's purpose without any filler or redundant information. Every word contributes to meaning.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description is mostly complete. It states what the tool does and the relevant context (current API key). However, it does not mention the return format or further details about the scopes, which could be useful but is not critical for such a simple tool.

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

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

The tool has zero parameters, so the baseline is 4 per the instructions. The description adds context about the API key but does not introduce any parameter-specific semantics since there are none to describe.

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

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

The description clearly identifies the tool as retrieving permission scopes for the current API key, which is a specific and distinct purpose compared to sibling tools like get_account_info or get_wallet_balance. The verb 'Get' and resource 'permission scopes' are 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?

The description implies when to use this tool (when needing to know available scopes for the API key) but does not explicitly state alternatives or exclusions. No guidance is given on when not to use it or how it relates to other tools, though this is a simple informational getter.

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?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns the 'most recent' address rather than generating a new one, which is a key behavioral trait distinguishing it from address creation tools. However, it does not mention authorization requirements, side effects, or error behavior, but for a simple getter this is acceptable.

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?

Single concise sentence with the key information front-loaded. Every word earns its place, and the parenthetical '(most recent)' adds crucial clarity without unnecessary verbosity.

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 single-parameter getter with no output schema or annotations, the description is reasonably complete. It clearly identifies what the tool does and the meaning of 'current'. However, it could explicitly state that no new address is created, but the parenthetical already implies this.

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

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

The schema already provides a complete description of wallet_id (100% coverage), and the description adds no additional meaning beyond referencing 'a wallet'. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses the specific verb 'Get' with a clear resource 'current (most recent) on-chain Bitcoin address' and scope 'for a wallet'. It distinguishes from sibling tools like create_onchain_address and send_onchain by focusing on retrieval of the existing latest address.

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 when you need to retrieve the wallet's latest on-chain address, but it does not explicitly contrast with alternatives such as create_onchain_address (which creates a new address) or state when not to use it. No exclusions or alternative guidance is provided.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only says 'Check the payment status' with no mention of read-only behavior, possible return statuses, error handling, or whether any side effects occur. This is insufficient for a tool with no annotation coverage.

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

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

The description is a single, front-loaded sentence that immediately states the action and object. Every word is essential, and there is no redundant or filler content.

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

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

The tool is simple (one parameter, no nested objects, no output schema). The description clearly states its purpose and parameter, but since there is no output schema, it does not explain what the response contains (e.g., status values like settled/pending). For a straightforward status check, this is adequate but leaves some ambiguity about the return format.

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

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

The schema description covers 100% of the single parameter (payment_hash) with a clear meaning. The description's phrase 'by payment hash' reinforces that the parameter is the identifier, but adds no new information beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb 'Check' and the resource 'payment status of a Lightning invoice', with the specific lookup method 'by payment hash'. This distinguishes it from sibling tools like get_invoice_status_by_request, which likely uses a different identifier.

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

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

The description implies the tool is used when you have a payment hash and need to check status, which is clear context. However, it does not explicitly mention alternative tools like get_invoice_status_by_request or subscribe_invoice_status, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden. 'Check' implies a read-only operation, but the description does not disclose the return format, whether it polls, error behavior, or explicitly state that no state changes occur. This is a significant gap for a tool with no output schema.

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

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

The description is a single, clear sentence that front-loads the purpose and includes the key differentiator (bolt11) without any wasted words.

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

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

For a simple one-parameter read tool, the description is minimally viable. However, with no output schema and no annotations, it should at least mention what the status response looks like (e.g., 'paid'/'unpaid') to be fully complete.

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

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

Schema description coverage is 100%, so the schema already documents the payment_request parameter. The description only restates 'bolt11', adding no new semantic value beyond what the schema provides.

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

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

The description uses a specific verb ('check') and clearly identifies the resource ('payment status of a Lightning invoice') and the lookup key ('by payment request (bolt11)'). This distinguishes it from sibling tools like get_invoice_status (which likely uses an invoice id) and subscribe_invoice_status.

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

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

The tool's usage is implied: use it when you have a bolt11 payment request and want its status. However, it does not explicitly state when not to use it or mention alternatives, which would be helpful given the many invoice-related 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?

With no annotations, the description carries the burden. The verb 'Get' indicates a read-only operation and the content is disclosed (network info, Lightning node details, fee information). It doesn't mention side effects or auth requirements, but for a simple global getter this is adequate.

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

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

The description is a single sentence, front-loaded with the verb, and includes specific details without wasted words. Every word earns its place.

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

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

For a 0-parameter tool with no output schema, the description covers the essential expectations (network information, node details, fee info). It could be more detailed about response structure, but given the simplicity, it is contextually sufficient.

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

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

The tool has zero parameters and schema coverage is trivially 100%. No parameter explanation is needed; baseline of 4 applies for zero-parameter tools.

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

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

The description clearly states the action ('Get') and resource ('global network information') with specific inclusions ('Lightning node details and fee information'), which distinguishes it from siblings like get_account_info or get_wallets.

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

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

The description implies use for network-wide information but does not explicitly mention when to prefer this over alternatives like estimate_lightning_fee for payment-specific fees. No exclusions or alternative references are provided.

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

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

With no annotations, the description must disclose behavior, but it only states the core action. It omits details about the response format, data granularity, or whether the returned history includes current data, leaving the agent with limited understanding of the tool's behavior.

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

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

The description is a single, clear sentence with no unnecessary words. It is front-loaded and effectively communicates the essential purpose without clutter.

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

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

For a simple read tool, the description is adequate but leaves gaps. It does not explain what the price history output looks like or how the time range maps to data frequency, and with no output schema or annotations, the agent may lack sufficient context to fully understand the returned data.

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

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

The schema provides full coverage for the single 'range' parameter, including an enum and description. The description's phrase 'specified time range' adds no new semantic detail beyond the schema, 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 clearly states the tool's function: retrieving Bitcoin price history for a specified time range. The verb 'Get' and resource 'Bitcoin price history' are specific, and the scope differentiates it from sibling tools like get_realtime_price.

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 when historical price data is needed, but it does not explicitly mention when to use this tool versus alternatives such as get_realtime_price or subscribe_price_updates. There is no guidance on exclusions or selection criteria beyond the basic function.

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?

No annotations exist, so the description carries the full burden; it implies a side-effect-free read and signals the value is live rather than cached, which is useful. However, it says nothing about refresh/caching behavior, rate limits, or whether the quote is a snapshot at call time — meaningful gaps for a 'real-time' tool with zero annotation coverage.

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

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

One short sentence with the resource and scope front-loaded and zero filler. Nothing is redundant or buried.

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

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

For a one-parameter read tool with no output schema and no annotations, this is close to sufficient: an agent knows what it returns conceptually (a price in a currency). The remaining shortfall is that with no output schema, the description could have sketched the return shape or pointed to get_supported_currencies for valid inputs.

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

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

Schema coverage is 100% and the single parameter already documents its default of USD, so the schema does the work. The phrase 'in a specified currency' adds nothing beyond it — no guidance on supported currency codes (get_supported_currencies exists as a sibling) or fallback behavior for unsupported 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?

States a specific verb and resource (get current real-time Bitcoin price) plus the scoping parameter (currency). It is clearly distinguishable from data-shaped siblings like get_price_history, but it never names the nearby alternatives (get_price_history, subscribe_price_updates, convert_currency) that an agent would actually have to choose between.

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?

'Current real-time' implies this is the point-in-time lookup versus a historical or streaming source, but that contrast is left implicit. There is no explicit when-to-use/when-not clause and no mention of subscribe_price_updates for continuous prices or get_price_history for past values.

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?

No annotations are provided, so the description carries full burden for behavioral disclosure. The description states 'Get list', which implies a read-only operation, but it doesn't disclose whether authentication is required, whether results are live or cached, the response format, or any potential failure modes. This is a minimal disclosure that falls short of full transparency.

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

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

The description is one short sentence, front-loaded with the action 'Get' and the resource 'list of all supported display currencies'. Every word earns its place, and there is no unnecessary detail or redundancy. It exemplifies concise, effective writing.

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

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

The tool is simple with no parameters and no output schema, but the description still leaves some open questions, such as the exact return format (e.g., array of currency codes?) and whether these currencies correspond to the values accepted by set_display_currency. Given the simplicity, the description is adequate for basic understanding but lacks enough context to be considered fully complete without further inference.

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 by the rubric baseline, this dimension earns a 4. The description adds no parameter information, but none is needed. The schema also confirms no properties, and the description fully covers the absence of parameters.

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

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

The description clearly states the tool gets a list of all supported display currencies, using the specific verb 'Get' and identifying the resource. It distinguishes itself from sibling tools like set_display_currency and get_realtime_price by focusing on the list of supported display currencies. However, it is a simple sentence without additional scope or caveats, so it doesn't reach the level of the highest examples.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Usage is only implied by the function name and description—use it when you need the supported display currencies—but there is no explicit 'when to use' or comparison with related tools like set_display_currency.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action and gives no information about authentication, error states, or behavior when the transaction is not found, relying on the tool name to imply a read operation.

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

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

The description is a single, clear sentence with no redundant words. It is appropriately sized for the tool's simple purpose and is immediately understandable.

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 get-by-ID operation, the description is adequate but minimal. It lacks any indication of return format or error behavior, and no output schema or annotations exist to fill that gap, though the tool's low complexity mitigates the 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 has 100% description coverage for both parameters, so the schema fully documents wallet_id and transaction_id. The description adds no extra meaning beyond the schema, which meets the baseline for full schema coverage.

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

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

The description uses a specific verb ('Get') and resource ('details of a specific transaction'), clearly conveying the tool's purpose. It distinguishes itself from list-style tools like get_transactions, though it does not explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_transactions or get_invoice_status. There are no conditions, prerequisites, or exclusions mentioned.

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

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

With no annotations, the description carries the full load, but it only discloses pagination support – which the schema's cursor and limit fields already document. It says nothing about sort order (newest first?), whether the entire history or a retention window is returned, or whether the call requires auth, all of which an agent would want to know before calling an unpaginated-looking read.

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

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

Two short sentences, front-loaded with the core action and scope, with zero filler. Nothing to trim and nothing buried.

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

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

Adequate minimum: it names the resource and mentions pagination. But with no annotations and no output schema, the description should carry the return shape (what a 'transaction' contains), default behavior when wallet_ids is omitted, and ordering – none of which appear here.

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

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

Schema description coverage is 100%, so the baseline is 3 with the schema doing the heavy lifting. The description adds little beyond confirming multi-wallet scope, and says nothing about the default-all-wallets behavior or the 100 cap at a higher level.

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 ('Get transaction history') plus the scope ('one or more wallets'), which distinguishes it from the single-record sibling get_transaction_by_id. It never names that sibling or explains the batch-vs-single distinction explicitly, so differentiation is left implicit.

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

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

No when-to-use guidance, no conditions for choosing this over get_transaction_by_id, get_wallet_balance, or other history-adjacent siblings. The only hint of scope ('one or more wallets') is repeated from the schema rather than presented as usage criteria.

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

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

The description adds a useful behavioral detail about return units (satoshis or cents), but it does not disclose error handling, authentication needs, or when each currency is used. With no annotations, the description carries the transparency burden but only partially fulfills it.

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

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

The description is two concise sentences with no redundancy. It front-loads the primary action and includes a valuable return-unit detail, earning its place.

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

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

The description is adequate for a simple getter, but it lacks the response shape and the conditions for when BTC vs USD is returned. Since there is no output schema, these details would improve completeness, but the core purpose is covered.

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

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

The schema already fully documents the wallet_id parameter with a description, so the baseline is 3. The description does not add any additional parameter semantics 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 clearly states the tool gets the balance of a specific wallet by ID, with a specific resource (wallet balance) and scope (by wallet ID). It effectively distinguishes from sibling tools like get_wallets (which lists all wallets) and get_account_info (account-level details).

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 usage: use when you have a wallet_id and need its current balance. It does not explicitly mention alternatives or exclusions, but the context is unambiguous given the tool name and description.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It adds valuable detail about units ('Balance is in satoshis for BTC wallet and cents for USD wallet'), which goes beyond the basic function and helps the agent interpret results correctly. No mention of read-only safety, but 'Get' implies a read operation.

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

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

The description is a single sentence, front-loaded with the primary action ('Get all wallets') and immediately provides essential unit information. Every word earns its place; there is 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, zero-parameter read tool with no output schema, the description covers what the tool does and the units of the returned balances. It is complete enough for an agent to select and use the tool without further clarification.

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

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

The schema has zero parameters, so the baseline is 4. The description adds no parameter info (there are none to describe), but it does provide useful context about return units, which is tangential to parameters. No gaps here.

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

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

The description clearly states the tool's function: 'Get all wallets (BTC and USD) with their current balances.' It specifies the resource (wallets), scope (all), and asset types (BTC and USD), distinguishing it from singular wallet tools like get_wallet_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?

The description clearly indicates this tool is for retrieving all wallets at once, which is implicit usage context. It does not explicitly mention alternatives or exclusions, but the name and description make the intended use clear enough without such 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool creates an invoice plus signed macaroon and returns a WWW-Authenticate header for HTTP 402, which gives strong behavioral context. It does not cover permissions, wallet requirements, or side-effect timing, but the core behavior is well described.

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 concise sentences with no wasted wording and is front-loaded with the core action and purpose. The return value is placed after the main purpose, which supports quick scanning.

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

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

The tool has no output schema, but the description explains the key return value: a WWW-Authenticate header for HTTP 402. Combined with a fully documented input schema, this is nearly complete, though it could state whether the challenge creation requires wallet configuration or whether invoice generation has side effects.

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 all five parameters in detail. The description does not add parameter-specific semantics beyond the schema, which is an appropriate baseline for a fully documented schema.

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

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

The description uses a specific verb and resource: 'Create an L402 payment challenge (invoice + signed macaroon)' and clarifies it protects a resource behind a Lightning paywall. This clearly distinguishes it from payment-oriented siblings like l402_pay or verification tools.

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

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

The description implies usage by saying it protects a resource behind a Lightning paywall, but it does not explicitly state when to use this instead of siblings such as l402_pay, l402_payment_verify, or create_invoice. The context is useful but alternatives and exclusions are left implicit.

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 no annotations, the description carries the burden and does the important part: 'without paying' tells the agent this is a non-mutating probe, and the return contents (invoice, price in sats, format) are disclosed. It omits edge behavior such as what happens when the URL has no L402 challenge and whether any credentials are needed, which keeps it short of a 5.

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

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

Two tight sentences, with the core action and the non-paying guarantee front-loaded before the comparison to l402_pay. No filler.

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

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

No output schema exists, so the description usefully enumerates what comes back (invoice, sats price, format flavor). For a simple 2-parameter probe this is nearly sufficient; only failure/edge-case behavior for non-L402 URLs is left implicit.

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

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

Schema description coverage is 100%: both url and the method enum are already documented in the schema. The description adds no syntax, format, or constraint detail beyond that, 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?

States a specific verb and resource ('Probe a URL for L402 payment requirements'), plus the key modifier 'without paying', and names the return values. It is clearly distinguishable from the sibling l402_pay, which actually spends funds.

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?

'Use this before l402_pay to check the cost of accessing a resource' gives an explicit ordering rule and names the alternative tool. The agent knows exactly when to reach for this instead of paying directly.

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 no annotations at all, the description carries the full behavioral burden, and it does disclose two important traits: it spends real Lightning funds and it consults a token cache to avoid double-paying. It omits failure modes (insufficient balance, amount over limit), whether payments are irreversible, where tokens are cached, and whether the cache is scoped per wallet, which matters a lot for a money-moving 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?

Three short sentences with zero filler, leading with what the tool does, then the cache-avoidance behavior, then the return value. Nothing here needs trimming or reordering.

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 6-parameter tool that spends real money with no annotations and no output schema, the description covers the happy path and the return value but not error behavior or the safety role of max_amount_sats. Adequate to call the tool, thin for calling 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 100%, so every parameter including url, force, dry_run, wallet_id, and max_amount_sats is already documented in the schema. The description only restates the cache behavior implied by force. Baseline 3 applies since the schema does the parameter work.

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: access an L402-protected URL by auto-paying the Lightning invoice. That is clearly distinguishable from generic payment tools. However, it never distinguishes itself from the closely related siblings l402_challenge_create, l402_payment_verify, or pay_invoice, even though the L402 family overlap is the main ambiguity risk.

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 holding a URL that returns HTTP 402 is the intended caller. There is no explicit when-to-use/when-not, and no routing advice to l402_challenge_create plus l402_payment_verify for the manual two-step flow, or to dry_run for price discovery before committing funds.

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 no annotations, the description carries the full burden and does well: it discloses the exact checks performed (SHA-256 preimage, HMAC authenticity, caveat expiry/resource) and the return shape. It stops short of stating that the operation is side-effect-free/idempotent or describing failure modes beyond a false result.

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 tight sentences: what it does, what it checks (numbered), and what it returns. Zero filler and the core action is 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?

Because there is no output schema, the description correctly includes the return value ('valid: true/false'). It could go further by explaining which of the three layers failed or what an agent should do on an invalid result, but for a focused verification tool it is nearly 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 token/macaroon/preimage/resource are already fully documented, including the alternative input forms. The description adds no additional parameter guidance, which is the expected baseline when the schema does the work.

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 ('Verify an L402 payment token') and immediately enumerates the three concrete layers being validated. This clearly separates it from siblings like l402_pay, l402_challenge_create, and l402_store, which create or consume rather than validate tokens.

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

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

The phrase 'submitted by a client' implies a server-side verification flow, giving implicit usage context. However, it never states when to prefer this over sibling tools or what to do on failure, so guidance remains implied rather than explicit.

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

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

With no annotations at all, the description carries the full burden, and 'Search' implies a read-only operation without stating it outright. It does disclose a meaningful behavioral difference between sources (result richness vs breadth of coverage), which helps an agent predict output quality, but says nothing about rate limits, auth, pagination, or result shape.

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, no waste, with the core action front-loaded and the source tradeoff immediately after. 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?

Four optional parameters and no output schema, so the description arguably should hint at what a search returns; it only does so obliquely through 'rich schema.' It is adequate to call the tool correctly but leaves an agent guessing about result shape and volume.

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 enum values, defaults, and keyword/category meanings are already documented. The description adds genuine meaning beyond the schema by characterizing each source ('curated, rich schema' vs 'broader coverage, 50+ services'), though it does not clarify 'status' or 'category' beyond the 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?

States a specific verb+resource ('Search L402 service directories') and the goal ('find paid APIs accessible with Lightning payments'), which is much clearer than a bare name restatement. However, it never distinguishes itself from the sibling tool l402_discover, which sounds like the same discovery capability.

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 a usable default/alternative framing for the source parameter ('curated, rich schema' vs 'broader coverage, 50+ services'), which is actionable. But it offers no guidance on when to call this at all versus l402_discover or l402_store, and no exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that listing masks sensitive data and where the cache lives on disk, but it does not state that 'clear' is destructive/irreversible, whether clearing without a domain wipes everything, or what happens when no token exists for a domain.

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 tightly written sentences: the resource and storage path are front-loaded, then the operation set. Every clause earns its place with no redundancy.

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

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

For a 4-parameter tool with no annotations and no output schema, the description is minimal but covers the resource and command set. It omits key behavior an agent needs: whether 'clear' is destructive/global, behavior on a cache miss for 'get', and the risk profile of exposing secrets via reveal.

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 enum, domain, reveal, and expired_only semantics are already fully documented in the schema. The description adds 'masked sensitive data' as corroborating context but no information beyond what the parameter descriptions provide, 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 description uses a specific verb ('Manage') with a concrete resource ('local L402 token cache at ~/.blink/l402-tokens.json') and enumerates the three supported operations (list/get/clear). This clearly separates it from siblings like l402_pay or l402_discover, though it never names those siblings 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?

It describes what each command does, which implies when to pick each one, but gives no explicit guidance on when to use this tool versus l402_pay/l402_discover or what prerequisites exist (e.g., no cached token yet). Usage is inferable rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it lists active subscriptions, but does not mention side effects, return format, pagination, or authorization requirements. This is minimal disclosure.

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

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

The description is a single, concise sentence that directly conveys the tool's purpose without any fluff. Every word contributes meaning.

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 listing tool, the description is adequate but not fully complete. There is no output schema, so the return structure is unspecified. The description implies a list but does not detail the content of the subscriptions.

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

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

The tool has zero parameters, so the baseline score is 4. There is no parameter information to add because the schema is empty, and the description offers no confusing parameter details.

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

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

The description 'List all active real-time subscriptions' clearly states the verb (list) and the specific resource (active real-time subscriptions). It distinguishes itself from sibling tools like list_webhooks by specifying the resource type.

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

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

No explicit guidance on when to use this tool versus alternatives. There is no mention of exclusions or prerequisites, though the simple nature of the operation makes it somewhat self-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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation but does not explicitly state that it causes no side effects, nor does it mention response format, pagination, or rate limits. For a simple list operation, this is acceptable but leaves some behavioral details unspecified.

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

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

The description is a single, concise sentence that front-loads the verb and resource. Every word earns its place, with no filler or unnecessary detail.

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

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

Given that the tool has no parameters and no output schema, the description provides a clear picture of what the operation does. It does not detail the exact return structure, but for a list operation the expected outcome (a list of endpoints) is sufficiently implied. The overall context is complete enough for an agent to invoke the tool correctly.

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

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

The tool has zero parameters, and the description is consistent with that (no parameter details omitted). Per the rubric, a zero-parameter tool receives a baseline of 4 because there is no additional parameter semantics to add beyond what the schema already conveys.

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 ('List') and a specific resource ('webhook callback endpoints') scoped to 'the account'. It clearly distinguishes itself from sibling tools like add_webhook and remove_webhook by indicating it is the read-only listing operation.

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 purpose is self-evident: use this when you need to see all registered webhooks. It does not explicitly state alternatives or exclusions, but the clear scope and the presence of add_webhook/remove_webhook make the usage context unambiguous. There is no need to mention alternatives for a simple listing tool.

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

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

No annotations, so the description carries the full behavioral burden, yet it does not say whether the lookup requires authentication, what happens when the username does not exist, or whether the wallet is created/hidden. Only the word 'default' hints at behavior (which of a user's wallets is selected), which is not enough for a no-annotation 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?

A single front-loaded sentence with no filler. Nothing redundant or wasteful for a simple read tool.

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 read tool with no output schema, the agent still lacks the return shape (wallet address? currency? both), error semantics for unknown usernames, and any auth requirement. The description is adequate as a label but incomplete as a calling 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 coverage is 100%, so both parameters are already documented, establishing a baseline of 3. The description's 'default wallet' phrasing reinforces the optional wallet_currency enum but adds no explanation of how currency changes the result.

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 (look up) and resource (a user's default wallet) scoped to a Blink username, which cleanly separates it from get_wallets (own wallets) and send_to_username. It is clear what it does, though it never explicitly contrasts itself with those 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?

Usable with a single required username; no explicit when-to-use or when-not, and no named alternatives for cases like resolving another user's wallet versus your own. In a 50-tool family with nearby wallet tools, that omission forces the agent to infer routing.

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

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

No annotations are provided, so the description carries full burden for a payment/mutation operation. It does not disclose irreversibility, fee behavior, authentication or wallet permission requirements, failure modes, or what a successful payment returns.

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

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

Two short sentences, front-loaded with the core action and followed immediately by the key precondition. There is no wasted 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 payment tool with no annotations and no output schema, the description is under-specified. It should explain payment result behavior, fee handling, irreversibility, and relevant sibling routing to be complete enough for safe invocation.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the input schema. The description adds only that the amount must be embedded in the invoice, which slightly reinforces the payment_request semantics but adds little beyond the schema.

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

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

States a specific verb and resource: 'Pay a Lightning invoice.' The constraint that the invoice amount must be specified distinguishes it implicitly from amountless siblings like pay_invoice_with_amount, but it does not name that 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?

The amount requirement implies when this tool applies versus amountless payment flows, but the description never explicitly says to use pay_invoice_with_amount for invoices without an amount, nor does it mention other alternatives such as pay_lightning_address or pay_lnurl.

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?

No annotations at all, so the description carries the full burden for what is an irreversible value transfer. It discloses nothing about irreversibility, whether funds move immediately, fee handling, or any auth/limit requirement. Beyond the single precondition it is silent on the behaviors an agent most needs to know before spending money.

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

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

Two short sentences, zero padding, with the distinguishing precondition front-loaded and the caller obligation second. Nothing could be cut without losing 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, yet the description says nothing about what a payment call returns (preimage, fee paid, status) or how failures surface. Combined with zero annotations on a financial mutation, the definition is callable but leaves meaningful gaps around outcome and safety.

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 all four parameters are already documented, including amount units and the positivity bound — baseline is 3. The description adds the meaningful semantic that amount is caller-determined and required because the invoice itself carries none, which explains why the field exists rather than just its type.

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

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

States a specific verb and resource ('Pay a Lightning invoice') with the qualifying condition that the invoice carries no amount, and that the caller supplies the amount. This clearly separates it from a plain pay_invoice, though the sibling is never named. An agent can identify the tool's job without opening the schema.

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

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

The precondition ('invoice has no amount specified') is stated, which implies the when-to-use case, but the alternative is never named and the failure mode (what happens if you use this on an invoice that already has an amount, or pay_invoice on an open invoice) is not addressed. Guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden but only restates what the tool sends. It omits that this is an irreversible fund transfer, whether fees are deducted, whether there is a confirmation step, and what happens on failure. For a money-moving operation this is a meaningful gap.

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

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

One tight sentence with the action front-loaded and zero filler. It is efficient, though the brevity comes at the cost of the behavioral detail noted elsewhere.

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 3-required-parameter payment tool with no annotations and no output schema, the description should say more about outcomes, fees, and irreversibility. It leaves the agent without enough context to invoke this confidently relative to sibling payment tools.

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

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

Schema description coverage is 100%, so amount, wallet_id, and ln_address are already documented in the schema; the description's example merely repeats the ln_address schema text. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a specific verb and resource ('Send Bitcoin to a Lightning Address') with a concrete example format. An agent can distinguish it from pay_invoice, pay_lnurl, and send_onchain, though the description never names those siblings to make the routing 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?

No guidance on when to use this versus pay_lnurl, pay_invoice, or send_to_username, and no prerequisites or exclusions stated. The agent must infer from the tool name alone that this is the Lightning Address path.

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?

No annotations are provided, so the description bears the full behavioral burden. It implies an irreversible transfer of funds but says nothing about fee handling, required wallet balance, permissions, whether a fee estimate should precede it, or what is returned on success/failure.

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

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

The single sentence is front-loaded and waste-free, but conciseness here reflects under-specification rather than discipline; a funds-moving tool warrants more structure.

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

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

For a destructive payment operation with no annotations and no output schema, the description omits nearly everything an agent needs: fee behavior, failure modes, and what a successful response indicates.

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 all three parameters (wallet_id, lnurl, amount) are already documented in the schema. The description adds only the parenthetical gloss on LNURL, which is baseline-level value.

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 ('Pay') and resource ('LNURL (Lightning URL)'), and glosses the acronym so an agent knows this is a Lightning payment. It does not differentiate LNURL from the many sibling payment tools (pay_invoice, pay_lightning_address, l402_pay), so it stops short of a 5.

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

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

There is no indication of when to choose this over pay_invoice, pay_invoice_with_amount, pay_lightning_address or l402_pay, and no preconditions are stated. The agent must infer the choice purely from the tool name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It fails to mention whether removal is permanent, requires authentication, or has side effects. The word 'registered' hints at existing endpoints but provides no practical detail.

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 clear sentence with no filler words. It efficiently states the tool's purpose.

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

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

Given the tool's simplicity, the description states the basic action but omits critical context such as consequences of removal, success/failure indicators, or any prerequisites. For a destructive operation, this is insufficient.

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

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

The schema already documents the 'id' parameter with 100% coverage. The description adds no additional parameter semantics beyond what the schema provides, 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 description uses a specific verb ('Remove') and resource ('webhook callback endpoint'), clearly distinguishing it from sibling tools like add_webhook and list_webhooks.

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 does not explicitly state when to use this tool or provide alternatives. It implies usage through the verb 'Remove' but lacks guidance on when to prefer it over similar 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It identifies this as an on-chain send and specifies satoshi units, but it does not disclose irreversibility, fee behavior, authorization requirements, failure modes, or whether the transaction is immediate.

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 short sentences and front-loads the core action. Every sentence contributes useful context without 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 financial mutation tool with no annotations and no output schema, the description is too sparse. It omits critical context such as transaction finality, fee implications, expected return behavior, and safety checks, leaving the agent under-informed before invoking a send 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 schema already documents all parameters, including amount, address, wallet_id, speed, and memo. The description reinforces that amount is in satoshis for a BTC wallet but adds little beyond the schema's own 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?

States a specific action and resource: 'Send Bitcoin on-chain to a Bitcoin address.' It clarifies amount units and BTC wallet context, making the operation distinct from Lightning sends, but it does not explicitly distinguish from sibling tools such as send_onchain_all or send_onchain_usd.

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

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

The description gives no guidance on when to use this tool versus alternatives like send_onchain_all, send_onchain_usd, or estimate_onchain_fee. It also omits prerequisites or conditions such as ensuring sufficient balance or confirming the address.

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?

No annotations are provided, so the description must carry the behavioral burden. It discloses that the entire balance is sent on-chain, but it does not mention irreversibility, fee implications, authentication needs, confirmation behavior, or what happens if the address is invalid or the wallet is empty.

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

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

The description is a single front-loaded sentence with no redundant or filler text. It states the operation and its sweep semantics immediately.

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

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

This is a high-risk financial mutation tool with no annotations and no output schema. The description identifies the operation but omits critical context such as irreversibility, fee behavior, and whether fee estimation should precede the sweep, leaving the definition under-specified for safe invocation.

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

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

Schema description coverage is 100%, so wallet_id, address, memo, and speed are already fully documented in the schema. The description adds only the high-level 'entire balance' scope and does not need to explain the individual parameters, making the baseline score of 3 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: 'Send the entire wallet balance on-chain to a Bitcoin address (sweep).' It clearly distinguishes this from the sibling send_onchain by emphasizing that the entire balance is swept rather than a specified amount.

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

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

Usage is implied by '(sweep)' and 'entire wallet balance,' suggesting this is for draining a wallet rather than sending a partial amount. However, it gives no explicit when-to-use guidance, no alternatives such as send_onchain or estimate_onchain_fee, and no preconditions or warnings.

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 no annotations, the description carries the full burden for a financial mutation tool. It discloses the action and source wallet, but omits critical traits such as irreversibility, fee implications (beyond what speed might imply in schema), balance requirements, or confirmation 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?

Two short sentences, front-loaded with the core action and scope. Every sentence earns its place with no wasted words.

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

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

For a high-stakes on-chain transaction tool with no annotations and no output schema, the description is too sparse. It should cover what happens on success/failure, fee handling, and irreversibility to be complete enough for an agent to call it confidently.

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 all parameters are already documented. The description repeats that amount is in cents, which the schema also states, adding no new semantic guidance beyond what structured fields provide.

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 (send) and resource (on-chain Bitcoin) scoped to a USD (Stablesats) wallet, which implicitly distinguishes it from the generic send_onchain. However, it does not explicitly name the sibling alternative, so the differentiation relies on inference.

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

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

No guidance on when to use this tool versus alternatives like send_onchain, send_onchain_all, or send_to_wallet_usd. The only implied context is the wallet type, but no explicit exclusions or prerequisites are provided.

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

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

With no annotations, the description carries the full burden, and it does add real value by disclosing that the transfer is intraledger, free, and instant, plus that a wallet lookup happens server-side. It omits critical behavioral facts for a money-moving operation: irreversibility, what happens if the username is unknown or the balance is insufficient, and any auth requirements.

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

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

Two short sentences with zero filler, and the identifying behavior (username-based intraledger send) is front-loaded before the cost/speed note.

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?

Incorrect on reflection — for a fund-transfer tool with no annotations and no output schema, the omission of failure modes and irreversibility is a genuine completeness gap; the description covers the happy path only.

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 all five parameters including units and the currency enum are already documented. The description adds no parameter-level meaning beyond confirming the recipient is identified by username; 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 names a concrete verb and resource ("Send Bitcoin to a Blink user by their username") and adds that it is an intraledger transfer, which distinguishes it from on-chain and Lightning-address payments among the siblings. It stops short of naming the closest alternative (send_to_wallet) explicitly, so the differentiation is implied rather than stated.

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

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

The description implies the selection condition — use this when you know the recipient's Blink username rather than their wallet or address — but never states when to prefer it over send_to_wallet, pay_lightning_address, or lookup_user_wallet. There are no exclusions, prerequisites, or fallback 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 no annotations, the description carries the full behavioral burden. It usefully discloses cost, speed, and transfer rail ('free, instant, intraledger'), but omits permissions, irreversibility, failure behavior, and confirmation details for a funds-moving mutation.

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 compact sentences with the key qualifier – intraledger transfer – front-loaded. No filler 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?

The core behavior and amount unit are covered, and the schema fully describes inputs. However, with no annotations and no output schema, the description does not say what happens on success/failure or whether the transfer is irreversible, leaving gaps for a value-transfer 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 coverage is 100%, so all four parameters are already documented in the schema. The description reinforces that amount is in satoshis for BTC wallets, but adds no semantic detail beyond the schema's own 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?

States a specific verb and resource: sends Bitcoin to another Blink wallet. The phrase 'intraledger transfer' clearly distinguishes it from on-chain siblings like send_onchain and from the USD variant send_to_wallet_usd.

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 clear context for use: another Blink wallet, free and instant. It does not explicitly name alternatives or when not to use it, but the intraledger constraint is unambiguous enough to route an agent correctly.

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

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

No annotations are present, so the description carries the full burden; it does add real behavioral context that 'send' alone wouldn't — cost (free), speed (instant), and rail (intraledger). It stops short of the traits that matter most for a funds-moving mutation: irreversibility, failure modes for an unknown/invalid recipient wallet, insufficient balance, and whether a memo is exposed to the recipient.

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

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

Two short sentences, zero waste, with the operation and its rail front-loaded and the unit caveat placed last where it lands as a reminder. Nothing redundant given the schema.

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 4-parameter fund transfer with no annotations and no output schema, the description establishes the rail and unit but says nothing about what is returned on success (transaction ID?) or what happens on failure. An agent can call it, but cannot predict the result.

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

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

Schema description coverage is 100%, with every property documented including the cents unit and the ownership distinction between wallet_id ('your wallet') and recipient_wallet_id. The description's 'Amount is in cents' merely restates the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Send USD (Stablesats) directly to another Blink wallet') and pins the transfer mechanics with 'intraledger', which cleanly separates it from the onchain and Lightning siblings (send_onchain_usd, pay_invoice, pay_lightning_address). An agent can identify the operation and its scope without opening the schema.

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

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

The parenthetical 'free, instant, intraledger transfer' implies when to prefer this over the paid onchain/lightning paths, but that preference is never stated as guidance and no sibling is named. It also omits the practical precondition that recipient_wallet_id is a Blink wallet ID that must typically be resolved first (e.g. via lookup_user_wallet or send_to_username).

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It fails to mention side effects (e.g., that this changes the default for future transactions), permission requirements, return value, or whether the change is persistent. This is a mutation tool with no disclosure beyond the basic effect.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the action and scope without redundant 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?

The tool is simple (one parameter, no output schema, no annotations), and the description covers the core purpose. However, it lacks information about what the tool returns, whether the operation requires authentication, and what happens if the wallet_id is invalid. This leaves gaps for an agent to confidently invoke the tool in a real workflow.

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

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

The schema already documents the single parameter wallet_id as 'The wallet ID to set as default', so schema coverage is 100%. The description adds marginal context about wallet types (BTC or USD) but does not provide any additional syntax, format, or validation details beyond what the schema gives.

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

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

The description uses the specific verb 'Set' and identifies the resource as 'default wallet for the account', with the explicit parenthetical '(BTC or USD wallet)' which adds helpful context. It clearly distinguishes from sibling tools like set_display_currency or set_username.

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

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

The description makes the action obvious but provides no explicit guidance on when to use this tool versus alternatives or any exclusion criteria. Sibling tools like set_display_currency are related but distinct, and no guidance is given for choosing between them.

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 no annotations provided, the description must carry the burden of behavioral disclosure. It states the action but does not indicate whether the change is persistent, account-wide, reversible, or how it affects other operations (e.g., price displays). No return value or side effects are mentioned.

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

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

A single, front-loaded sentence states the purpose clearly with no redundant words or information. It is appropriately concise for a simple setter tool.

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

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

Given low complexity (1 parameter, no output schema), the description is minimally adequate. However, it lacks behavioral context (persistence, side effects) and does not reference related tools like get_supported_currencies to guide the user on currency selection. This leaves gaps for a complete understanding.

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

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

Schema description coverage is 100%, so the schema already describes the 'currency' parameter. The description adds an extra example (BTC) but no additional semantic details such as whether the code must match a supported list or case sensitivity. Baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Set') with a clear resource ('display currency for the account'). It distinguishes from siblings like set_default_wallet by explicitly naming the target resource, and includes concrete examples (USD, EUR, BTC) that clarify the 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?

The description provides no guidance on when to use this tool versus alternatives such as get_supported_currencies or set_default_wallet. There is no mention of prerequisites (e.g., checking supported currencies) or exclusions. Usage is only implied by the verb 'Set'.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It neither mentions whether the change is permanent, whether it requires special permissions, nor what side effects may occur. This is a significant gap for a mutation tool.

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

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

The description is a single, clear sentence with no redundancy. It is concise and front-loaded with the action and resource.

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

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

Given the tool's low complexity (one parameter, no output schema), the description is adequate but not complete. It lacks details on outcomes, validation errors, or the relationship to check_username_available, which would be helpful for an agent to invoke it correctly.

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

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

The schema covers the single 'username' parameter fully with 'The new username', and the tool description aligns with that. No additional constraints or format details are given, but schema coverage is 100%, so the baseline of 3 applies.

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

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

The description uses a specific verb ('set or update') and targets a clear resource ('username for the current user'), which distinguishes it from sibling tools like get_account_info or check_username_available. It clearly states the action's scope and 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 implies use when changing one's own username, but it does not mention prerequisites (e.g., checking availability with check_username_available) or when not to use it. No explicit alternatives or exclusions are given, so guidance is only implied.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only states 'subscribe' without disclosing how updates are delivered (e.g., webhook, streaming), whether the subscription is persistent or one-time, authentication requirements, or side effects such as creating a managed subscription.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. It contains no filler or redundant information.

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

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

Given the tool involves subscription management (evidenced by sibling tools like list_subscriptions, cancel_subscription), the description lacks essential context about the subscription lifecycle, how updates are received, and how to stop them. With no annotations or output schema, this is a significant gap for a tool that likely has side effects.

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 per the rubric the baseline is 4. The description adds no parameter details, but none are needed since the schema is empty and schema coverage is 100%.

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

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

The description clearly states the verb 'subscribe' and the resource 'all real-time account updates', specifying the scope as including incoming/outgoing transactions and price updates. This distinguishes it from sibling tools like subscribe_invoice_status and subscribe_price_updates.

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

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

The description implies the tool is for receiving account-level real-time updates but provides no explicit guidance on when to prefer it over alternatives like subscribe_price_updates or subscribe_invoice_status. There are no exclusions or conditional usage notes.

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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states that a subscription ID is returned for tracking/canceling, but it does not disclose how real-time updates are delivered (e.g., webhook vs. polling), whether a webhook must be configured, any permission requirements, or the side effect of creating a persistent subscription. This is a significant gap for a subscription 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 two sentences long, front-loaded with the core action and return value. Every phrase earns its place ('Subscribe to real-time updates', 'Returns a subscription ID to track or cancel'). It contains no 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?

The tool is part of a subscription ecosystem (siblings include add_webhook, list_subscriptions, cancel_subscription), but the description omits how updates are actually received, whether a webhook endpoint is required, and what the agent should do with the subscription ID beyond 'track or cancel'. With no output schema and no annotations, these are important gaps that make the description incomplete for effective use.

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

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

The schema has 100% coverage for the sole parameter (payment_request) with the description 'The bolt11 payment request to monitor'. The tool description adds no extra meaning beyond the word 'Lightning invoice', which is already implied. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Subscribe to real-time updates') and the resource ('Lightning invoice payment status'), and mentions the key return value (subscription ID). However, it does not explicitly differentiate from the closely-related sibling subscribe_invoice_status_by_hash, which monitors the same status by hash; the distinction (payment_request vs. hash) is only in the schema, not the description.

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

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

There is no guidance on when to use this tool versus alternatives like get_invoice_status for one-time checks or subscribe_invoice_status_by_hash when a payment hash is available. The description simply describes the action without any context or exclusions, leaving the agent without direction on choosing among 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Subscribe to real-time updates' without explaining how updates are delivered (e.g., webhook, websocket), whether the subscription is long-lived or requires cancellation, or what the response looks like. This is insufficient for a subscription tool.

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

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

The description is a single, concise sentence that is front-loaded with the core purpose. It contains no redundant or extraneous information, making it efficient and easy to parse.

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

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

Given the absence of annotations and output schema, and the existence of a very similar sibling tool (subscribe_invoice_status), the description is too sparse. It does not clarify delivery mechanisms, subscription lifecycle, or how to disambiguate from similar tools, leaving critical context missing.

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

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

The schema provides 100% coverage of the single parameter with a clear description ('The payment hash to monitor'). The tool description adds no additional semantic detail beyond what the schema already states, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Subscribe to real-time updates') and the resource ('Lightning invoice by payment hash'). It differentiates from sibling tools like subscribe_invoice_status by explicitly specifying the hash-based subscription, making the purpose unambiguous.

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

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

The description implies usage for monitoring invoice status via payment hash, but does not explicitly state when to choose this over the similar sibling tool subscribe_invoice_status, nor does it mention any prerequisites or exclusions. It provides no direct guidance for selecting this tool among alternatives.

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

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

With no annotations at all, the description carries the full burden and leaves key traits unstated: whether subscribing creates persistent server-side state, how updates are delivered (push vs. polling), whether the subscription is tied to a session or account, and how it is torn down. Only 'real-time' hints at behavior, which is thin for a stateful subscription operation.

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

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

One short sentence, front-loaded with the verb and resource, with no filler. Nothing is wasted.

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

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

For a stateful subscribe operation with no annotations and no output schema, the description should say what the caller receives and how the subscription is managed or cancelled. Those essentials are missing, leaving an agent unable to predict the result of a successful 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?

There is a single parameter with 100% schema description coverage and a documented default of USD, so the schema already does the work. The description's phrase 'in a specified currency' adds nothing beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb (subscribe) and resource (real-time Bitcoin price updates) with a currency scope. It is distinguishable from the sibling get_realtime_price by the word 'subscribe', but it never names that sibling to make the distinction 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?

The description gives no guidance on when to use this instead of a one-shot read like get_realtime_price, nor any mention of prerequisites. It also omits the natural follow-up path for a subscription tool, such as cancel_subscription or list_subscriptions, which are present as siblings.

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