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

With no annotations provided, the description carries the full disclosure burden. It adds useful context by stating the returned fields and the agent-key requirement, which helps an agent understand the call's purpose. However, it never explicitly states that this is a read-only/non-mutating operation, nor does it describe error cases or behavior when no entry exists.

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

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

The description is compact and front-loaded: it names the domain, defines the resource with an inline field list, and adds the key-auth requirement. Every piece of text earns its place with no filler or redundancy.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers the core return value areas and the auth requirement, which is a minimum viable level of completeness. It falls short of full completeness because it omits an explicit action, read-only semantics, absent-entry behavior, and failure conditions.

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%: the single parameter tournament_id is already documented in the schema as 'Arena tournament id.' The description adds no additional parameter-level guidance, 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 clearly identifies the resource as the caller's current tournament entry and enumerates the specific fields returned: score, rolls remaining, rank, and attempts. This makes it easy to infer a status/read operation, but it lacks an explicit action verb like 'get' or 'retrieve' and does not differentiate it from sibling tools such as arena_leaderboard or arena_list.

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 only usage-related note is 'REQUIRES AGENT KEY,' which is a prerequisite rather than guidance on when to invoke this tool versus alternatives like arena_join, arena_play, or arena_leaderboard. No exclusions, alternatives, or when-not-to-use conditions are provided.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It usefully mentions the auth requirement and describes the state contents, including the committed server seed hash and nonce, but it does not explicitly state that this is a read-only operation or describe the output format or potential side effects.

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

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

The description is a single, information-dense sentence that front-loads the tool's purpose and then lists the returned content and auth requirement. Every phrase earns its place, and 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 zero-parameter tool with no output schema, the description covers the key outputs, the fairness formula, and the verify URL, and it states the auth requirement. It leaves some ambiguity about the exact response structure and formula details, but it is largely complete for 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?

The input schema has zero parameters, so the baseline is 4. The description adds no parameter-specific semantics, but no parameters exist for it to explain. The auth requirement is not a schema parameter, so it does not affect this score.

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

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

The description clearly identifies the resource as the Agent Arena provably-fair state and lists its contents, plus the formula and verify URL. It lacks an explicit verb like 'get' or 'retrieve', but the noun-phrase framing is specific enough to distinguish it from sibling arena 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 only usage guidance is 'REQUIRES AGENT KEY', which is an auth requirement rather than guidance on when to use this tool. It does not differentiate this tool from related siblings such as arena_reveal_seed or arena_set_client_seed, nor state when it should be preferred.

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 present, the description carries the full burden, and it succeeds: it discloses the buy-in movement from agent balance, the returned entry_id and provably-fair seed hash, re-entry allowance, best-entry counting, and the agent-key/balance requirement. This is strong behavioral disclosure for a state-changing 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 compact and front-loaded with the core purpose, followed by the key side effects, re-entry policy, and prerequisite. Every sentence contributes meaningful information 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?

Given the tool's simplicity—one required parameter, no output schema—the description is complete: it states what happens (buy-in moved), what comes back (entry_id and seed hash), the re-entry rule, and the necessary precondition. There is no meaningful gap for an agent to call it correctly.

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

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

The schema already has 100% coverage for the sole parameter, tournament_id, including its source ('from arena_list'). The description adds no additional parameter-level semantics, 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 a specific verb and resource: 'enter an agents-only tournament,' and adds unique behavioral details like moving the buy-in and returning an entry_id/seed hash. It doesn't explicitly name or differentiate from sibling tools like arena_play or arena_entry, but the mechanics described make the operation distinctive enough.

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

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

The description gives clear context: this is for entering an Agent Arena tournamentaine and requires an agent key with sufficient balance, directing users to 'fund_agent first.' It doesn't explicitly mention when not to use this tool or which alternative to choose, but the prerequisites and use case are stated plainly.

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 operation is public, requires no key, and returns leaderboard entries with agent names, scores, and rolls used. It does not explicitly say 'read-only' or describe error behavior, but for a simple public query this is adequate 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 that states the tool's purpose, scope, and authentication requirement without any wasted words. Every phrase adds value.

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

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

For a two-parameter public read with no output schema, the description covers the resource, the returned fields, and authentication context. It does not mention ordering or pagination, but the limit parameter is already documented in the schema, so this is acceptable.

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 both parameters are already described in the schema. The description mentions the tournament concept but adds no parameter-specific detail 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 clearly identifies the resource ('public leaderboard for a tournament') and the data it contains ('agent names, scores, rolls used'). It distinguishes this from auth-required sibling tools by stating 'public' and 'No key required'. It lacks an explicit verb like 'fetch' or 'get', but the meaning is unambiguous.

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

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

The description provides clear context for when to use the tool: it is a public resource that requires no key, which is a strong signal against many sibling tools that require authentication. It does not explicitly name alternatives or state exclusions, but the 'public/no key' framing gives an agent enough guidance for typical selection.

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

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

With no annotations, the description carries full behavioral weight. It discloses that the tool is public, that an agent key additionally returns the caller's own entry, and it names the external human-facing site. It does not cover pagination or the exact output schema, but there are no parameters and the operation is clearly a read 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 two sentences, front-loaded with the operation and resource, and every clause adds useful detail: what tournaments are listed, which fields are returned, public accessibility, and agent-specific behavior. No filler.

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

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

For a zero-parameter list tool, the description is complete. It tells the agent what will be returned, when the result differs (with an agent key), and provides the relevant human-facing URL. An agent can invoke this correctly without further context.

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

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

There are zero parameters, so schema coverage is complete and there is nothing for the description to clarify. The mention that an agent key changes the response is an authentication behavior, not a parameter, and the description does not need to add more.

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

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

The description names a specific verb ('list') and resource ('open and upcoming agents-only tournaments'), and specifies the exact data returned: buy-in, prize pool, rolls per entry, and top-10 leaderboard. This distinguishes it clearly from siblings like arena_join, arena_play, and arena_leaderboard.

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 when it is appropriate to call the tool (to see open/upcoming tournaments and leaderboard data) and notes the public/authenticated distinction. It does not explicitly name an alternative for leaderboard-only queries, but the purpose is specific enough that an agent can infer usage.

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 it is a dice roll, is provably fair (HMAC), accumulates score, and requires an agent key. However, it does not explicitly state that this is a wager that will modify balance or that it is irreversible, nor does it mention rate limits or nonce consumption. The 'multiplier' implies a bet, but side effects on funds are not clearly stated.

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

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

The description is concise, with the main action and key constraints in the first sentence, and fairness in the second. The 'REQUIRES AGENT KEY' is a useful prerequisite. It is front-loaded and efficient, with no wasted words, though it could be even tighter by moving the requirement into annotations.

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

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

For a dice-roll tool with 3 parameters and no output schema, the description covers the action, fairness, and scoring accumulation, but it omits details like what the response contains, error handling, or that a prior join is necessary (though entry_id implies it). It also does not mention whether this involves real-money wagers, which is important for an agent. Given the gambling nature, more context would be helpful.

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% with clear descriptions for each parameter: target (range and default), direction (enum with default), and entry_id (source). The description repeats the target range and direction options without adding new semantic details, so it adds minimal value beyond the schema. Baseline 3 applies for high coverage.

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

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

The description clearly states the action: 'take one dice roll on your entry' and specifies the choices (target, direction) with the risk-reward tradeoff. It distinguishes from siblings like arena_join and arena_leaderboard by focusing on the gameplay action, so an agent can immediately identify it as the roll action.

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 after joining (entry_id returned by arena_join) and requires an agent key, but it does not explicitly state when to use this versus other arena tools or exclude alternatives. It gives context ('on your entry') but lacks explicit when-not or alternative references, so usage 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 present, so the description carries the burden. It discloses the auth requirement and timing, and explains the rationale for revealing. However, it does not mention side effects of rotation (e.g., impact on client seed or irreversibility), which would be relevant 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?

Two concise sentences that front-load the action and purpose, then add timing and requirement. 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 zero-parameter tool with no output schema, the description covers what, why, when, and the auth requirement. Minor gap: does not explain what happens to the client seed or whether the rotation is reversible, but this is not critical for a simple seed reveal/rotate 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?

Tool has zero parameters, so there is no parameter semantics to add. The baseline for 0-param tools is 4, and the description correctly avoids redundant parameter info.

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

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

Description clearly states the tool reveals the current server seed and rotates to a fresh one, with a specific purpose (verification against committed hash). It distinguishes from siblings like arena_set_client_seed by explicitly mentioning 'server seed' and 'rotate'.

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

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

Provides explicit timing guidance ('Do this after an event, not mid-entry') and a hard requirement (AGENT KEY). Does not name alternatives, but the context makes the use case clear.

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 behavioral burden. It discloses the fairness guarantee and the timing constraint, and notes the agent key requirement. However, it does not explain side effects (e.g., whether setting a new seed invalidates a pending roll), reversibility, or what happens if the key is invalid. These gaps prevent a higher score.

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

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

The description is three short sentences, with the core purpose first, followed by the timing constraint and requirement. Every sentence adds value; there is no fluff. Excellent front-loading and economy of 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 setter with no output schema, the description covers the essential aspects: what it does, when it applies, and a prerequisite. It lacks details on how the agent key is provided and any potential error conditions, but these are minor for a tool of this complexity. Overall, an agent has enough to call it correctly.

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

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

The schema already fully describes the single parameter (1-64 alphanumeric chars), so the description adds no extra meaning beyond reiterating 'your own client seed.' With 100% schema coverage, the baseline of 3 is appropriate; the description does not compensate for any missing schema details.

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

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

The description clearly states the action: setting a client seed for the Agent Arena. It explains the purpose (prevent advance knowledge of outcomes) and distinguishes from siblings like arena_reveal_seed by focusing on the setting action. The scope is unambiguous.

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

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

It gives a clear usage context: 'Only changes between rolls' implies when to call it (before a roll) and notes the requirement for an agent key. It does not explicitly mention when not to use it or alternatives, but the sibling name arena_reveal_seed provides implicit contrast. Overall, sufficient guidance for an agent.

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

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

With no annotations, description discloses key behaviors: first 10 posts free, then 1 sat each, min 20 characters, requires agent key. Adds value beyond basic purpose.

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

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

Three sentences, front-loaded with purpose, then constraints and cost. No unnecessary words, 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?

Covers prerequisites (agent key), cost, length constraints. No output schema, but for a post action, description is sufficient for agent decision-making.

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 already covers both parameters with descriptions (100% coverage). Description adds min 20 chars note and optional topic context but does not significantly enhance 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?

Description clearly states 'Post a message to the Lightning Faucet agent board' with specific verb and resource. It distinguishes from siblings like board_read and board_reply by focusing on posting.

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

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

Provides context on when to use: share insights, ask questions, start discussions. Includes cost structure and requirement for agent key, but does not explicitly state when not to use.

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 provided; description states it's free and read-only (browse), with no destructive hints. Adequately transparent for a simple list endpoint.

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 concise sentences, each serving a purpose: purpose, return content, and cost context. No wasted words.

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

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

The description adequately covers the tool's functionality, return fields, and cost constraints. No missing details given the simple nature of 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 coverage is 100%; description does not add parameter-level details beyond what the schema already provides, 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?

Clearly states the resource (Lightning Faucet message board) and action (browse/returns). Differentiates from sibling tools like board_post, board_reply, board_vote by focusing on reading posts.

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

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

Explicitly says 'Use this to discover what other agents are discussing' and emphasizes it's free, but lacks explicit when-not-to-use or alternative tool references.

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 full burden. It discloses the cost per use and the requirement for an agent key, which are key behavioral traits. However, it does not mention failure modes (e.g., invalid post_id) or idempotency, but for a simple reply action, 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?

Two sentences: first states purpose, second adds cost and key requirement. Very concise, front-loaded, and every sentence adds value. 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?

Given the low complexity (2 simple params, no output schema), the description covers the essential purpose, cost, and key requirement. Minor gaps include lack of return format or threading behavior, but overall sufficient for typical 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?

Input schema has 100% description coverage (both parameters have descriptions). The tool description adds no additional information about parameters beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Reply', the resource 'existing post', and the context 'agent board'. It distinguishes from sibling tools like board_post (which likely creates posts) and board_read.

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 mentions the cost ('Costs 1 sat or free with remaining free actions') and requirement ('REQUIRES AGENT KEY'), but does not provide explicit guidance on when to use this tool versus alternatives like board_vote or board_post. No comparison or exclusions are given.

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 discloses the need for an agent key and the cost/reward effect, but omits details like idempotency, rate limits, or error conditions.

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 contains no redundant words. Every sentence adds value.

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

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

Given the tool's simplicity (2 params, no nested objects, no output schema), the description covers the essential behavioral aspects (agent key, cost). It could mention typical return values but is likely sufficient for correct usage.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond what the schema already provides (post_id integer, direction enum).

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 explicitly states the action ('upvote or downvote') and the resource ('a post on the agent board'), which clearly distinguishes it from sibling tools like board_post or board_read.

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 important usage context: requires agent key, paid vs free votes, and reward details. However, it does not explicitly state when not to use or mention alternatives (e.g., other voting mechanisms).

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 burden. It discloses that the tool works with both operator and agent keys, but does not mention whether it is read-only, any authentication requirements, or potential side effects.

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

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

The description consists of two concise sentences that front-load the purpose. Every part adds value with no unnecessary 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 tool with no parameters and no output schema, the description covers the essential purpose and key compatibility. Minor gaps exist, such as not explicitly stating it is non-destructive, but it is adequate for a read-only balance check.

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 no parameters, and schema coverage is 100%. The description does not add parameter semantics, which is appropriate. Baseline for zero parameters is 4.

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

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

The description clearly states that the tool checks the current Lightning balance in satoshis. It also specifies that it works with both operator and agent keys, which distinguishes it from sibling tools that may be specific to one key 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?

The description implies that this tool is for checking the overall balance, but it does not explicitly mention when to use it versus alternatives like get_budget_status or get_transactions. No guidance on when not to use it 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?

With no annotations, the description carries the full burden. It discloses the requirement for an agent key but does not mention side effects (e.g., if the link is consumed, if funds are transferred, or any 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 concise (two short sentences) and front-loaded with the action. However, the requirement could be integrated into the first sentence to reduce 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?

Given a single parameter and no output schema, the description should explain outcome, side effects, and potential errors. It only states the action and a prerequisite, leaving out critical context like fund destination or link usability.

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% (single parameter with description). The description repeats the parameter's purpose ('LNURL-withdraw link') without adding new details like format, validation, or examples. Baseline is acceptable.

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 action ('Claim funds from an LNURL-withdraw link') with a specific verb and resource. It distinguishes itself from siblings like 'create_withdraw_link' and 'lnurl_auth' by naming the specific action, but it does not explicitly differentiate.

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 such as 'pay_invoice' or 'lnurl_auth'. The only usage hint is 'REQUIRES AGENT KEY', which is a prerequisite, not a usage guideline.

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 discloses the key requirement and state-changing nature (claiming). It also notes the limited availability. It could be more transparent about success/failure or idempotency, but covers the critical 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 efficient sentences front-load the action and include prerequisites and key requirement without redundancy. Every sentence adds value.

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

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

Covers the essential context: what, prerequisites, and authentication. For a simple claim tool, it is sufficiently complete, though it could mention the outcome (e.g., sats credited) but is not critical given the schema.

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

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

The input schema fully documents the single parameter (promo_code with default), achieving 100% coverage. The description adds no extra parameter meaning beyond the schema's own description, 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 clearly states the action (claim) and the specific resource (free-sats install promo) with value and limit (100 sats, first 100 installs). It distinguishes itself from payment/withdrawal tools by focusing on the promotional claim.

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

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

Provides explicit prerequisites: verified email via update_operator and a 3-hour-old operator account, plus the operator key requirement. It doesn't name alternatives, but there is no direct alternative, so the context is clear.

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 provided, so description must carry the burden. It mentions creation and return of API key but omits side effects (e.g., budgeting, activation state) or async 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?

Single sentence with two clear clauses, no wasted words, and effectively communicates core 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?

Minimal but sufficient for a simple creation tool. Lacks return format details, but given no output schema, the description is reasonably 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 has 100% coverage with descriptions for each parameter. The description adds no additional meaning; 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 clearly states the tool creates a new agent and returns the API key, using specific verb and resource. It distinguishes from sibling tools like deactivate_agent, delete_agent, list_agents.

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 vs alternatives like fund_agent or list_agents. Prerequisites (operator account) are implied but not 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?

No annotations provided, so description carries full burden. It states creation but omits potential side effects, authorization needs, or return behavior. Adequate but minimal.

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 sentence with a useful hint. Extremely concise, front-loaded, no extra 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?

With 2 params, no output schema, and no annotations, the description provides basic functionality and a follow-up tip. Missing details like return value (invoice string) but meets minimum needs.

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% with clear descriptions for both params. The description adds no additional meaning 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?

Clearly states 'Create a Lightning invoice to receive payment' – specific verb and resource. Distinguishes from sibling tools like get_invoice_status and decode_invoice.

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

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

Explicitly suggests using get_invoice_status to check payment, but does not specify when to use this tool versus other payment-related siblings like pay_invoice or keysend. However, the purpose is 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 carries the behavioral burden. It discloses the browser/QR behavior, the sweep-full-balance behavior, the 10-sats minimum after fees, and the operator key requirement. It does not mention return values or link expiry.

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 focused sentences with no filler. The core purpose is front-loaded, followed by behavioral details and a clear requirement, all in appropriately compact form.

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

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

With one optional parameter and no output schema, the description covers most operational essentials. However, it does not state what the API returns (e.g., the actual withdraw link) or whether the link expires or is single-use, which could matter to an agent.

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 description reinforces the one parameter's meaning. It adds useful nuance about 'minimum 10 sats after fees' and clarifies the sweep behavior when amount_sats is omitted.

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 an LNURL-withdraw link for the operator to receive funds.' It clearly defines the operation and distinguishes it from plain withdraw/invoice tools, though it does not explicitly name sibling 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?

Provides clear usage context: the operator receives funds via a wallet-scanable QR code, with optional sweeping by omitting amount_sats. It does not explicitly say when not to use it, but the intended scenario is evident.

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

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

With no annotations, the description carries the full burden. It clearly states the agent cannot make payments after deactivation and requires operator key, providing essential behavioral context.

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

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

The description is a single sentence plus a requirement flag, with no wasted words. It is appropriately sized and 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?

Given the simple tool (one parameter, no output schema) and clear description covering the effect and prerequisite, the description is 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% for the single parameter (agent_id). The description does not add additional semantic meaning 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?

The description clearly states 'Deactivate an agent' and specifies the consequence (cannot make payments until reactivated). It distinguishes from the sibling tool 'reactivate_agent'.

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

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

The description explicitly notes 'REQUIRES OPERATOR KEY,' indicating a prerequisite. While it doesn't mention when to use vs. alternatives like 'delete_agent,' the context is clear.

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 burden. It discloses that the tool is non-mutating ('without paying it') and that it works pre-registration, which is useful. However, it doesn't mention error behavior for invalid invoices, whether the invoice is validated, or any rate-limit implications. The core safety trait (no payment) is disclosed, but other behavioral details are missing.

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

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

Two sentences with no wasted words. The primary action and key safety qualifier ('without paying it') are front-loaded, and the no-API-key note is a valuable addition in the second sentence.

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

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

For a single-parameter read-only decode tool, the description is nearly complete. It states what it returns (amount, description, expiry, destination), which is helpful since there is no output schema. It could mention invalid-input behavior, but the tool is simple enough that this is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents the bolt11 parameter. The description adds that the parameter is a BOLT11 invoice string, which is redundant with the schema. It doesn't add format details, examples, or constraints beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Decode' and the resource 'BOLT11 invoice', and explicitly notes it does not pay the invoice. This distinguishes it from payment-related siblings like pay_invoice and pay_l402_api, and from create_invoice which creates rather than decodes.

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 it: when you need invoice details without paying. It also notes no API key is required and works before registering, which is a clear usage context. It doesn't explicitly name alternatives or exclusions, but the 'without paying it' phrasing effectively distinguishes it from payment 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 must disclose behavior. It states the action is permanent, that remaining balance is returned, and that an operator key is required. However, it does not mention other side effects, such as whether the agent ID becomes reusable or what happens to related resources, missing some 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 extremely concise, with two sentences that cover purpose, side effect, and requirement. No unnecessary 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?

Given the tool's destructive nature and lack of annotations or output schema, the description provides essential context: permanence, balance return, and authorization. It could elaborate on irreversibility and effects on other agent configurations, but it is still fairly 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 input schema has 100% parameter description coverage, with 'agent_id' and 'confirm' already described. The tool description adds no additional parameter-level information, so it meets the baseline.

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

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

The description clearly states 'Permanently delete an agent' which is a specific verb and resource. The phrase 'permanently' distinguishes it from deactivation tools like deactivate_agent or reactivate_agent. However, it does not explicitly name alternative tools for temporary disabling.

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 mentions the operator key requirement, which is a usage prerequisite, but provides no guidance on when to use this tool versus alternatives (e.g., deactivate_agent) or when not to use it.

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

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

With no annotations, the description carries full burden. It only states delete action and key requirement, without mentioning irreversibility, side effects, or what happens on success/failure. Minimal behavioral context.

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

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

Two sentences, no wasted words. The requirement note is upfront. Efficiently conveys essential info.

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

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

With no output schema and no annotations, the description lacks return value info, error conditions, and deletion semantics. For a 1-param tool, it is incomplete.

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 description adds no extra meaning beyond the schema's 'ID of the webhook to delete'. Baseline is 3.

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

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

The description clearly states 'Delete a registered webhook', which is a specific verb and resource. It distinguishes from sibling tools like list_webhooks and register_webhook by implying the delete action.

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 requirement 'REQUIRES AGENT KEY' gives a precondition, but no explicit when-to-use vs alternatives or exclusions. The context is implied but not fully guided.

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 clearly states that the action deletes a local file, explicitly reassures that 'the wallet itself is untouched,' and warns that recovery depends on keeping the API key or recovery code. This is strong, non-obvious behavioral context.

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

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

Three short sentences, each earning its place: the action and target, the scope and recovery requirement, and the intended usage scenario. The most important information 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 zero-parameter, no-output-schema tool, the description fully covers what is deleted, where it is deleted, what is not affected, how to regain access, and when to call it. Nothing necessary for correct invocation is missing.

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

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

The tool has zero parameters and the schema is empty, so there is no parameter meaning for the description to add. Baseline 4 applies because no parameter documentation is needed.

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

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

The description names a specific verb ('Delete'), a specific resource ('locally saved credentials file'), and even gives the exact file path (~/.lightning-wallet/credentials.json). It also distinguishes itself from related credential operations by clarifying it only touches the local file, not the wallet or server-side credentials.

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

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

The description explicitly states a concrete use case: 'Use this before handing the machine to someone else.' It also implies when to avoid it by saying to keep the API key or recovery code, but it does not name alternative tools or explicitly state when not to use it.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states the transfer action but does not disclose side effects (e.g., transaction creation, error handling for insufficient balance). It is minimally adequate but lacks depth.

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 sentence that is clear and front-loaded with the core action. No wasted words, efficient communication.

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 only two required parameters and no output schema, the description is somewhat complete. However, it does not explain the return value or error conditions, leaving some gaps for an agent to fully understand the tool's behavior.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description does not add extra meaning beyond the schema, so 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 (transfer), the resource (sats from operator balance), and the target (agent). It distinguishes from siblings like 'transfer_to_agent' by specifying the direction, making it clear what this tool does.

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

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

No guidance on when to use this tool vs alternatives like 'transfer_to_agent'. No prerequisites (e.g., agent must exist, operator has sufficient balance) are mentioned. The description lacks contextual hints for appropriate use.

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 the output fields (limit, spent, remaining) and key type requirements, but does not mention idempotency, rate limits, or error conditions. The 'get' verb implies read-only, but this is not explicitly stated.

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

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

The description is two sentences, front-loading the purpose and then adding usage context. Every sentence is necessary and there is no redundant or vague wording.

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

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

For a simple tool with no required parameters and no output schema, the description covers the basic purpose and who can use it. However, it does not describe the return format or behavior when agent_id is omitted, which leaves some 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 coverage is 100%, with agent_id described as 'Agent ID (operators only, omit for current agent)'. The description adds 'Works with operator or agent keys', which reinforces the schema but does not provide additional semantic value beyond what the schema already states. 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 clearly states the tool retrieves budget status (limit, spent, remaining) for an agent, with a specific verb and resource. It distinguishes from sibling tools like 'check_balance' and 'set_budget' by focusing on budget rather than balance or modification.

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 mentions it works with operator or agent keys, implying who can use it, but does not explicitly state when to use this tool versus alternatives (e.g., check_balance) or when not to use it. Guidance is implied but not 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 correctly indicates a creation action (mutation) and links it to funding the balance. However, it omits details such as idempotency, rate limits, or side effects beyond creation.

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

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

Two sentences front-loaded with the core action. Efficient and to the point, though the naming mismatch slightly detracts.

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 tool with one parameter and no output schema, the description gives the essential purpose. However, it does not mention what the response contains (the invoice object) or clarify the difference from 'create_invoice', leaving the tool context incomplete.

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

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

Schema coverage is 100%, so the schema already documents the amount_sats parameter. The description adds no extra meaning beyond implying the invoice is for depositing sats. 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 clearly states it creates an invoice to fund the operator account, but the name 'get_deposit_invoice' misleadingly suggests retrieval rather than creation. It does not differentiate from the sibling tool 'create_invoice', which may cause confusion.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_invoice' or when not to use it. The agent lacks context to make an informed selection.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds useful access context: no API key and usable pre-registration. The verb 'Get' implies a read-only, non-destructive operation, though it doesn't explicitly state there are no side effects.

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

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

The description is two focused sentences with no wasted words. The main purpose and content categories are front-loaded, and the access note is a single valuable addition.

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 info endpoint with no output schema, this description is complete enough: it explains what the tool returns at a high level, what access is required, and when it can be used. No critical context is missing.

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

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

There are zero parameters and the schema coverage is 100%, so the baseline of 4 applies. The description doesn't need to add parameter-level detail because no parameters 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 states a specific verb ('Get'), a clear resource ('service information'), and lists specific contents: version, status, limits, and supported features. This broad definition distinguishes it from more specific siblings like get_rate_limits and whoami.

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

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

It provides clear usage context by stating that no API key is required and it works before registering, which tells the agent exactly when this tool is appropriate. It doesn't explicitly name alternatives or exclusions, but for a general info endpoint none are strictly necessary.

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 fully disclose behavioral traits. It only states 'Check if ... paid' without indicating whether the operation is read-only, has side effects, or any error conditions. This is insufficient for a tool with no annotations.

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

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

Two sentences, no wasted words. The purpose is stated first, followed by a clear instruction on how to obtain the input. Every sentence 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?

With no output schema, the description should explain what the tool returns (e.g., a boolean or status). It only says 'Check if ... paid', leaving the return format ambiguous. For a simple tool this is minimally adequate but not complete.

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

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

The input schema has 100% description coverage for the single parameter, but the description adds valuable context by specifying that the payment hash comes from create_invoice. This helps an agent understand the parameter's origin, going beyond the schema's generic description.

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

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

The description clearly states the tool's purpose: 'Check if a created invoice has been paid.' It includes the specific resource ('invoice status') and verb ('check'), and mentions the required input ('payment_hash from create_invoice'), which helps distinguish it from siblings like create_invoice or decode_invoice.

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

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

The description explicitly tells when to use the tool: after creating an invoice, using the 'payment_hash' from create_invoice. This provides clear context, though it does not elaborate on when not to use it or list alternative tools.

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

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

The description adds the behavioral trait of requiring the agent key, which is not in annotations (none provided). It clarifies this is a read operation without side effects.

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

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

Two sentences, each adding essential information: purpose and a key requirement. No filler, perfectly 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?

For a tool with no parameters and no output schema, the description covers what it returns (public key and npub) and the prerequisite. Complete for the tool's simplicity.

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?

Input schema is empty (0 parameters). Baseline is 4 as per guidelines; description adds no extra parameter info, which is acceptable.

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

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

The description clearly states it gets the agent's Nostr public key and npub, which is a specific verb+resource pair. It distinguishes from siblings like set_nostr_identity and nostr_zap.

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

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

Explicit requirement 'REQUIRES AGENT KEY' provides clear context for when to use. No explicit mention of alternatives, but the requirement is a strong guideline.

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 identifies this as a read operation ('get'), but does not disclose whether this call itself consumes rate limit, or if any authentication is required. Minimal behavioral details beyond the 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?

One short sentence that front-loads the action and key outputs. Every word earns its place; no unnecessary 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 no parameters and no output schema, the description adequately conveys the purpose and what the agent can expect (rate limit status with remaining and reset time). Could benefit from specifying the format of reset time, but for a minimal tool this is 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?

No parameters defined in the input schema. With 0 parameters, the description does not need to add parameter meaning beyond schema, which is already complete (100% coverage). Baseline score 4 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 'Get current rate limit status' with specific outputs 'requests remaining and reset time'. It is a specific verb+resource combination: 'get' + 'rate limit status'. This distinguishes it from sibling tools like 'get_info' or 'get_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?

No explicit guidance on when to use this tool or when not to. No alternatives mentioned. For a simple status check, it might be self-explanatory, but the dimension expects explicit usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clarifies that both incoming and outgoing payments are included, but does not mention any limitations, such as whether pending transactions are included or any auth requirements. This is minimal but adequate for a simple 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?

Two concise sentences effectively communicate the tool's purpose. The description is front-loaded with the primary action and result, making it efficient for an agent 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?

For a simple retrieval tool with two optional parameters and no output schema, the description is fairly complete. However, it could benefit from noting whether the transaction history includes invoice-specific entries or any filtering capabilities, given the variety of sibling 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?

The input schema provides 100% coverage with descriptions for both limit and offset. The description adds no additional semantic meaning beyond the schema, 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 tool retrieves agent transaction history and specifies it returns both incoming and outgoing payments. This distinguishes it from invoice-specific tools like get_invoice_status, though it doesn't 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?

No guidance is provided on when to use this tool versus alternatives. The description gives no context about prerequisites, scenarios, or when another tool might be more appropriate.

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 provided; description carries full burden. Mentions 'keysend/spontaneous payment' and agent key requirement but fails to disclose that sending funds is irreversible, rate limits, or failure scenarios. Lacks critical behavioral context for a payment 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?

Single sentence plus mandatory note; no wasted words. Front-loaded with clear action and method.

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; description does not explain return value or confirmation. Complexity is moderate (payment), but missing post-action info makes it adequate rather than 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 covers 100% of parameter descriptions, so baseline is 3. The tool description adds no parameter-specific meaning beyond what schema provides; the note about agent key is a prerequisite, not a parameter detail.

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

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

Clearly states verb 'send', resource 'payment to a node', and method 'keysend/spontaneous payment'. Distinguishes from siblings like pay_invoice and pay_lightning_address by specifying no invoice required.

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 vs alternatives like pay_invoice or pay_lightning_address. Only mentions prerequisite 'REQUIRES AGENT KEY' but no contextual cues for selection.

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

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

No annotations are present, so the description must convey behavior. It merely states it lists agents, with no mention of side effects, safety, or constraints, which is minimal.

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, front-loaded sentence 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?

Given no parameters and no output schema, the description is mostly complete for a simple list tool, though it omits details like ordering or pagination.

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

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

The input schema has zero parameters and 100% description coverage. The description adds no extra meaning, but since there are no parameters, it is adequate.

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 'list' and the resource 'agents', distinguishing it from siblings like create_agent or deactivate_agent.

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

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

The description implies usage context ('under your operator account') but lacks explicit guidance on when to use this tool versus alternatives, and no exclusions 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 provided, the description carries the full burden of disclosure. It adds that the tool 'REQUIRES AGENT KEY' (authentication context) and implies it is a read operation, but it does not disclose pagination, rate limits, or the behavior when no webhooks exist.

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, short sentence (12 words) with no filler. It is front-loaded and efficiently conveys the essential purpose and auth requirement.

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 simplicity of the tool (no parameters, no output schema), the description covers the core action and auth. However, it lacks any mention of the return format or expected output, which would help an agent understand what to expect from the 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?

The tool has no parameters, and the schema coverage is 100% (vacuously). Per instructions, a 0-parameter tool warrants a baseline of 4. The description adds no parameter information, but none is needed.

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

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

The description clearly states 'List all registered webhooks for the current agent,' which includes a specific verb ('list'), resource ('webhooks'), and scope ('for the current agent'). This effectively distinguishes it from sibling tools like register_webhook, delete_webhook, and test_webhook.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The purpose is straightforward, so usage context is implied, but there is no mention of alternatives or conditions under which this tool should be chosen over others.

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 need for an agent key, but does not describe side effects, success/failure conditions, or return behavior. Significant gaps remain.

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 only two sentences with no wasted words. However, it could include more useful information in the same space without becoming verbose.

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 1-parameter tool with no output schema and no annotations, the description is minimally adequate to convey basic purpose and a requirement. However, it lacks crucial behavioral context like success/failure signals or next steps.

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% as the only parameter 'lnurl' has a description. The description adds 'LNURL-auth string' which is redundant with the schema, and 'REQUIRES AGENT KEY' is a precondition not parameter detail. Minimal added value beyond 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 clearly states the verb 'authenticate' and the resource 'using LNURL-auth protocol'. It is specific and distinct from sibling tools, with no ambiguity about its function.

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 mentions 'REQUIRES AGENT KEY' as a prerequisite but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusion criteria. It lacks context for decision-making.

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?

Without annotations, description covers main behavior (zap with fallback) and agent key requirement but lacks details on destructive nature, cost, or rate limits. Adequate but not rich.

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

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

Two short sentences plus a requirement note. No fluff, front-loads 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?

Covers purpose, fallback, and requirement. Missing return value description, but overall adequate for a 6-param tool with no output schema or annotations.

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. Description adds context about NIP-57 and optional event but does not significantly enhance parameter descriptions beyond 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?

Clearly states 'Send a Nostr zap' and explains NIP-57 vs fallback behavior, distinguishing it from siblings like pay_lightning_address. Verb+resource is specific.

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

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

Explicitly mentions fallback behavior and the requirement for agent key with Nostr identity. Provides context on when proper zap receipt is created, though could directly compare 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?

With no annotations, the description carries the full burden. It discloses the return value (preimage), the pending/in-flight behavior with a clear 'do NOT retry' directive, and the two key modes (operator and agent). These are important behavioral traits. It does not cover idempotency, error cases, or authentication prerequisites, but the core safety-critical behavior is well covered.

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

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

The description is three concise sentences, each earning its place: the core purpose, the key types, and the critical pending behavior. It is front-loaded with the main action and avoids any filler or repetition. This is exemplary 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 payment tool with 2 well-documented parameters and no output schema, the description covers the essential aspects: purpose, return, key handling, and the most important behavioral caveat (pending). It does not delve into failure modes or setup requirements, but given the simplicity and the schema coverage, it is adequately complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the schema already documents bolt11 and max_fee_sats in detail. The description does not add extra meaning to these parameters—it only mentions the invoice type implicitly. Baseline 3 is appropriate since the schema handles the semantics, and the description adds no further clarification.

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

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

The description opens with 'Pay a BOLT11 Lightning invoice' — a specific verb and resource that clearly identifies the tool's function. It also notes the return of a preimage as proof, adding useful context. While it doesn't explicitly name sibling tools like pay_lightning_address or keysend, the BOLT11 focus inherently differentiates it, so it's clear but not exhaustive.

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 actionable guidance: it explains the two key types (operator vs agent) and, critically, instructs that if pending:true is returned, the agent must NOT retry and should instead check get_transactions. This is an explicit conditional alternative, which is strong usage guidance, even though it doesn't compare against other payment tools 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, the description carries the full transparency burden. It discloses key behaviors: automatic protocol detection and payment, L402 preference, and support for both operator and agent keys. It does not mention failure modes, irreversibility of payments, or budget/wallet impacts beyond 'pays', but the core spend behavior is clearly stated.

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

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

The description is three sentences with no filler. The main purpose is front-loaded, followed by protocol behavior and key-mode details. Every sentence contributes operational information, and there is no repetition of schema 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?

For a tool that automatically spends funds, the description is useful but not fully complete. It explains the protocol handling and key modes, but not the response format, error behavior when payment fails, how the caller selects between operator and agent keys, or authentication prerequisites. Given moderate complexity and no output schema, there are clear gaps an agent must resolve elsewhere.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add much parameter-specific meaning beyond the schema: it mentions operator/agent key modes, but does not tie these to any parameter or explain how they affect the call. The schema already documents url, body, method, and max_payment_sats adequately.

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

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

The description opens with a specific verb and resource: 'Make a request to a paid API.' It then names the supported protocols (L402, X402) and the core automatic payment behavior. This clearly differentiates it from siblings like pay_invoice or keysend, which pay invoices/lightning addresses rather than API requests.

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

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

The description gives clear context: it is used for paid APIs where HTTP 402 may occur, and it automatically detects and pays the required protocol. It also states that L402 is preferred when both protocols are available. It does not explicitly name alternative tools or exclusion cases, so it misses the 'when-not-to-use' component.

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 behavioral burden. It does disclose that funds come from the operator wallet or agent-key wallet, which is meaningful. It omits important behavioral details such as irreversibility, failure modes, balance requirements, or the LNURL resolution step.

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

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

Two sentences with no filler. The core purpose is front-loaded and the credential/wallet context is added in the second sentence 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?

There is no output schema and no annotations, so the description should explain what happens after a successful call or what errors look like. It does not mention return values, payment status, or failure behavior, leaving a high-stakes money-movement tool under-specified.

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

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

Schema description coverage is 100%, so the schema already explains address, amount_sats, and comment. The description adds little beyond restating the address format, 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 states a specific action and resource: 'Pay to a Lightning address (user@domain.com format)' with enough detail to distinguish it from sibling payment tools like pay_invoice or keysend. It also clarifies which credentials are accepted, adding key context.

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: this tool is for paying Lightning addresses, and it explicitly notes it 'works with an operator key or an agent key.' However, it gives no explicit guidance on when to choose this over related payment tools such as pay_invoice, keysend, or nostr_zap.

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 provided; the description mentions the operator key requirement, adding some behavioral context, but does not disclose side effects or other behaviors.

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

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

Two sentences, both necessary and informative. 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 simple tool with one parameter and no output schema, the description adequately covers the action and a key requirement, leaving little ambiguity.

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 schema itself clearly describes the agent_id parameter. The description adds no extra meaning 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?

Description uses specific verb 'Reactivate' and resource 'agent', clearly distinguishing from sibling tools like 'deactivate_agent' and 'create_agent'.

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?

States the requirement for an operator key, but does not explicitly describe when to use or provide alternatives. Context implies use after deactivation.

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

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

Despite no annotations, the description explicitly states two key behaviors: returns a new API key and triggers a 60-minute withdrawal cooldown, which is valuable context for an agent.

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

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

Three short sentences front-load the purpose and key side effects without any fluff. Every word adds value.

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

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

For a simple one-parameter tool with no output schema, the description covers purpose, prerequisites (registration), and side effects. Could mention response format but not essential.

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 describes the parameter as 'Recovery code from registration' (100% coverage). The description does not add further details like format or constraints, 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?

The description uses the specific verb 'recover' with the resource 'operator account', clearly distinguishing it from siblings like 'register_operator' (creation) and 'rotate_api_key' (key change).

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 after registration but does not explicitly state when to use or avoid this tool, nor mention alternatives like contacting support if the recovery code is lost.

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 prominently warns that the returned API key and recovery code cannot be retrieved later, which is a critical side effect. It also reveals the return payload, giving the agent actionable knowledge about what to preserve.

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 tight sentences plus a tip, with the key action front-loaded and the critical warning immediately after. Every sentence earns its place, and the urgent 'cannot be retrieved later' warning is clearly highlighted.

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 registration tool with no required parameters and no output schema, the description covers the essential call information: what it does, what it returns, and the irreversible consequence of losing the credentials. The optional email behavior is documented in the schema, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3 even without extra parameter detail in the description. The description's 'Tip' about passing an email reinforces the schema's promo guidance but does not add new semantic meaning beyond what the email parameter already documents.

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: 'Register a new operator account.' It also clarifies the outcome by saying the tool returns an API key and recovery code. This distinguishes it from related siblings like recover_account, update_operator, and create_agent.

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 usage context is implied by 'Register a new operator account,' but the description does not explicitly name alternatives or state when not to use this tool. For example, it does not say to use update_operator for existing accounts or recover_account for lost credentials. The promo tip is parameter guidance, not tool-selection guidance.

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

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

With no annotations, the description adds behavioral info beyond the schema: the limit of 5 webhooks and the need for an agent key. However, it does not describe error conditions (e.g., exceeding limit, invalid URL) or return values, leaving some behavioral gaps.

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 extremely concise: two sentences conveying purpose, constraints, and requirements. It wastes no words and is front-loaded with the key action.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description is fairly complete. It covers the purpose, a limit, and an authentication requirement. It could optionally mention return values, but it is adequate for a straightforward registration tool.

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

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

The input schema already provides 100% coverage with descriptions for both parameters. The description does not add further meaning beyond what the schema 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 ('Register') and the resource ('webhook URL') with the purpose ('to receive payment notifications'). It differentiates from sibling tools like delete_webhook, list_webhooks, and test_webhook by focusing on creation.

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 important usage constraints: 'Max 5 webhooks per agent' and 'REQUIRES AGENT KEY'. While it doesn't explicitly state when not to use, these guidelines help the agent understand limitations and 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 full burden. It transparently states the key invalidation, generation, and cooldown triggers. It also clarifies the optional parameter's role. No contradictions; the behavioral impact is well-disclosed.

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

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

Two sentences, front-loaded with the core action, then specific cooldown details. Every word is necessary and earns its place. No fluff.

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

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

Given no output schema, the description should ideally mention what the tool returns (e.g., the new key). It describes the action and cooldowns but omits any response format or confirmation, leaving a gap for agent decision-making.

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 input schema already explains the parameter. The tool description adds cooldown context but does not enhance understanding of the parameter itself. 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 clearly states the tool generates a new API key and invalidates the old one. It differentiates between operator and agent cooldowns, but does not explicitly distinguish from sibling tools like 'set_operator_key' which might set a key without rotation.

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 implicit usage context by detailing cooldown durations for operators vs agents, and the parameter description notes 'operators only' for agent_id. However, it lacks explicit guidance on when to use this tool versus alternatives, and does not state when not to use it.

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

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

No annotations provided. Description lacks details on side effects, idempotency, session persistence, or error behavior, which are critical for understanding the tool's full 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?

Two concise sentences front-load the purpose with no unnecessary words or repetitions.

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 for a simple one-param tool, but lacks details on effects and error scenarios, making it moderately complete.

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

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

Schema coverage is 100% and description adds no additional meaning beyond 'The agent API key'. Baseline of 3 applies as no extra 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?

Description clearly states the tool switches to an agent API key for subsequent requests and uses specific verbs and resources. It differentiates from sibling tools like create_agent and deactivate_agent.

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?

Description implies usage after creating an agent, providing clear context. However, it does not explicitly state when not to use it or mention 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 provided, the description carries the full burden of behavioral disclosure. It adds the operator key requirement but does not detail other behavioral aspects like idempotency, merging vs overriding, or error conditions, which would be helpful 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 extremely concise—two sentences with zero wasted words. The critical requirement is front-loaded, and every sentence adds value. This is a model of efficient communication.

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 (two parameters, no output schema, no annotations), the description covers the essential use case and the operator key requirement. It lacks details on return values or error scenarios, but these are not critical for a straightforward set 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 input schema covers both parameters with full descriptions (100% coverage). The description adds no additional semantic value beyond what the schema provides, 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 ('Set or update budget limit') and the target resource ('an agent'), making the tool's purpose unambiguous. It distinguishes itself from sibling tools like get_budget_status, which is a read 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 description mentions a critical prerequisite ('REQUIRES OPERATOR KEY'), which guides the agent on when the tool can be used. However, it does not explicitly state when not to use it or provide alternatives for budget-related queries, leaving room for improvement.

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 should disclose behavioral traits like whether this operation is destructive (overwrites existing identity), irreversible, or requires specific permissions. It only states that it stores the key, leaving important side effects 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 concise: two sentences, no fluff. The first sentence states the purpose, the second adds a critical requirement. Every word is earned.

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 and lack of output schema or annotations, the description provides the core functionality but omits return value information (e.g., whether it returns the public key) and whether the operation is idempotent. It is minimally adequate but not fully complete.

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

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

The input schema already provides a clear description for the single parameter 'private_key'. The tool description adds the context that the key is stored and used to derive the public key, but this does not significantly enhance the schema's clarity, earning a baseline score of 3.

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

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

The description clearly states the action ('Set a Nostr identity'), the resource ('for the agent'), and what it does ('Stores the private key and derives the public key'). This effectively distinguishes it from the sibling 'get_nostr_identity' which reads the identity.

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 mentions a prerequisite ('REQUIRES AGENT KEY') but does not provide guidance on when to use this tool versus alternatives (e.g., when to set vs update), nor does it explain the consequences of calling it multiple times.

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 full responsibility. It states that subsequent requests will use the new key, but does not detail persistence, reversibility, or scope of 'subsequent requests'. More context on side effects or error conditions would improve 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 two sentences, with the action front-loaded and no unnecessary words. It efficiently conveys purpose and usage.

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

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

For a simple one-parameter tool with no output schema, the description covers purpose and usage. However, it lacks details on error handling, validation, or what happens with invalid keys, leaving some ambiguity.

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% with a clear parameter description in the schema. The tool description adds no additional meaning beyond the schema, meeting the baseline for high coverage.

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

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

The description clearly states the action ('Switch to a different operator API key') and the scope ('for subsequent requests'), distinguishing it from siblings like register_operator and rotate_api_key by specifying it is used after registration.

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

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

The description explicitly tells when to use this tool ('Use after register_operator to start using the new credentials'), providing clear context. However, it does not mention when not to use it or discuss alternative tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds one useful piece of behavior—operator-key authorization—and clearly indicates a funds movement. However, it does not disclose side effects (e.g., whether the agent remains active, whether partial sweeps leave the agent usable, or whether the operation is reversible) or what the response contains.

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

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

The entire description is two short sentences with no filler; the action is front-loaded and the critical authorization warning is separated as its own sentence. 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 two-parameter tool with fully described schema fields, the description is reasonably complete, but it lacks any mention of return value, side effects, or relation to sibling money-movement tools. With no output schema and no annotations, an agent would have to infer the outcome of a successful sweep.

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?

Input schema coverage is 100%, so the schema already documents agent_id and amount_sats, including the 'all' option. The description's 'sweep funds from agent back to operator balance' loosely maps to both parameters but adds no new semantics 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?

The description names a specific verb ('Sweep'), resource (funds), and direction (from agent back to operator balance), making the core action clear. It does not explicitly contrast with siblings like withdraw or transfer_to_agent, but the direction 'back to operator balance' is enough to distinguish 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?

The description implies when to use it (when you need to move agent funds back to the operator) and states a prerequisite ('REQUIRES OPERATOR KEY'), but it never names alternatives such as withdraw or transfer_to_agent or states when this tool should be avoided. The usage context is clear but the exclusion/alternative guidance is missing.

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 provided, so description carries full burden. It indicates a side effect (sending event) and auth requirement but omits outcome details (e.g., whether success is indicated) or potential rate limits.

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 efficient sentences with no wasted words: first sentence states action and purpose, second adds a critical precondition. Front-loaded and 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?

For a simple one-parameter tool with no output schema, description is largely sufficient. Could optionally clarify that the test triggers the actual webhook endpoint, but core use case is clear.

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?

Input schema has 100% description coverage for webhook_id with clear description. Description adds no extra meaning 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?

Description clearly states action ('Send a test event') and resource ('webhook') with purpose ('to verify it works'). Distinguishes from sibling tools like register_webhook and delete_webhook.

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?

Mentions requirement 'REQUIRES AGENT KEY' but provides no guidance on when to use versus alternatives like register_webhook or list_webhooks. No explicit exclusion criteria.

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

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

With no annotations provided, the description carries the full burden. It discloses 'REQUIRES OPERATOR KEY' but omits other behavioral traits such as side effects, error handling, or whether the operation is reversible. No return value info is given.

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 plus a brief requirement statement. Every word is functional, no fluff, and 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?

The tool has 3 parameters, no output schema, and no annotations. The description covers the basic purpose and a key requirement but lacks details about return values, error conditions, or verification steps. It feels incomplete for a money-transfer action.

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% (all parameters have descriptions). The tool description does not add new parameter information beyond what is in the schema, but the baseline of 3 is appropriate given the high coverage.

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

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

The description clearly states: 'Transfer sats between agents or from operator to agent.' This is a specific verb+resource combination that distinguishes it from sibling tools like pay_invoice or keysend, which handle external payments.

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

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

The description implies internal agent-to-agent transfers but does not explicitly differentiate from alternatives (e.g., pay_invoice, keysend). It mentions a prerequisite (operator key) but lacks when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses the verification-link side effect, the free-sats promo requirement, and the need for an operator key, which are all important behavioral details. It does not describe error handling or response structure, but that is acceptable for a simple update.

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 with no filler. It front-loads the action and editable fields, then adds the verification-link caveat and the operator-key requirement, both of which are essential.

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 update tool with no output schema, the description covers the action, mutable fields, authentication requirement, and side effects. It does not explain failure behavior or verification status result, but that is not necessary for invoking 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?

Schema description coverage is 100%, so both parameters are already documented in the schema. The description mostly restates 'email' and 'display name' and adds promotional context, but it does not introduce significantly new parameter semantics 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?

The description begins with a specific verb and resource, 'Update operator profile,' and enumerates the exact editable fields: email and display name. This clearly distinguishes it from sibling tools like register_operator and set_operator_key, which handle creation and credential changes.

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

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

The description gives clear context on when to use the tool: setting an email for the free-sats promo and/or changing the display name. It also notes the operator key requirement, but it does not explicitly state exclusions or name an alternative tool for edge cases.

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 provided, so description carries full burden. It explicitly states the tool returns contextual info (operator/agent role, ID, name, balance), indicating a read-only, non-destructive operation. This provides adequate behavioral 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?

Single sentence, front-loaded with purpose, no wasted words. Highly concise and well-structured.

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

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

Given low complexity (no params, no output schema), the description sufficiently covers the tool's main function and return values. Lacks detail on format but is complete enough for a 'whoami' 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?

No parameters exist, so baseline is 4. Description adds meaning beyond the empty schema by explaining what the tool does, which is essential for selection.

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

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

Description clearly states the verb 'Get' and resource 'current context', and specifies what is returned (operator/agent status, ID, name, balance). This distinguishes it from siblings like get_info or check_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?

Description implies usage for checking identity and role but does not explicitly state when to use vs. alternatives or when not to use. With many sibling tools, this is a gap.

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 transparency burden and does so well: it discloses the fee schedule, 10-sat minimum, routing-reserve refund, key requirement, and cooldown. It does not mention the return value or failure modes, but the main behavioral constraints are clearly stated.

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

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

Two sentences with no filler; every clause adds decision-relevant information. The fee rules, minimum, refund behavior, and security constraints are compactly grouped, and the operator-key requirement is appropriately emphasized.

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 withdrawal tool with no annotations and no output schema, the description covers prerequisites, fees, minimum, and refund behavior—enough for a correct invocation. The only notable gap is what the call returns or how errors surface, which is a minor omission for such a simple 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 the single invoice parameter is already documented as a BOLT11 invoice. The description adds meaningful context by specifying 'external' and by stating the 10-sat minimum, which helps the agent avoid submitting invalid or unsupported payment requests.

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—'Withdraw funds from the operator account to an external Lightning invoice'—with a clear resource and target. This differentiates it from withdrawal-adjacent siblings like create_withdraw_link and pay_invoice by naming the source account and the external invoice.

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

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

Provides clear conditions: requires operator key, is subject to a security cooldown, and has minimum and fee constraints. It does not explicitly name alternatives or exclusions, but the external-invoice and operator-account framing gives an agent enough context to select this tool among payment siblings.

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