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 states the tool checks status and shows possible states (pending, approved, rejected, expired), which is basic behavioral info. However, it lacks details on permissions needed, rate limits, error handling, or whether this is a read-only operation (though implied by 'check').

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

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

The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured by separating the status options, but it's appropriately sized with no wasted words.

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

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

For a simple read tool with one parameter and no output schema, the description is adequate but has gaps. It covers the basic purpose and output states, but lacks details on behavioral aspects like error cases or response format. Without annotations or output schema, more context would be helpful for 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?

The description adds minimal meaning beyond the input schema, which has 100% coverage for the single parameter 'approval_id'. The description mentions 'by ID', aligning with the schema's description, but doesn't provide additional context like ID format or examples. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's purpose: 'Check the status of a specific approval by ID' with the specific verb 'check' and resource 'approval status'. It distinguishes from siblings like 'botwallet_pending_approvals' (which lists approvals) by focusing on a single approval ID, but 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?

The description implies usage when you need to check an approval's status by its ID, but doesn't provide explicit guidance on when to use this versus alternatives like 'botwallet_pending_approvals' or 'botwallet_list_fund_requests'. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries full burden. It describes what information is returned (balance, budget, spent amount, allowance, low balance flag, funding URL) but doesn't disclose behavioral traits like rate limits, authentication requirements, or whether this is a read-only operation. The description adds useful context about what data is included but lacks operational details.

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

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

The description is efficiently structured in two sentences: the first lists all returned data points, the second provides clear sibling differentiation. Every sentence earns its place with no wasted words, and key 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?

Given the tool's complexity (read-only balance check with multiple data points), no annotations, and no output schema, the description does well by listing all returned data fields and providing sibling differentiation. However, it doesn't specify the return format or structure, which would be helpful given the lack of output 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 tool has 0 parameters with 100% schema description coverage. The description appropriately doesn't discuss parameters since none exist. It provides context about what data is returned, which adds value beyond the empty 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 tool's purpose with specific verbs ('check') and resources ('live on-chain USDC balance, spending budget, amount spent this period, remaining allowance, low balance indicator, funding URL'). It explicitly distinguishes from sibling botwallet_info by specifying what metadata is not included, making the distinction clear.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: it states to use botwallet_info for wallet metadata (status, owner, creation date, claim info). This gives clear context for tool selection among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates the precondition (only pending paylinks are cancellable) and implies a mutation action ('Cancel'), but lacks details on permissions, rate limits, error conditions, or what happens upon cancellation. It adds some context but is incomplete 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 two sentences with zero waste—the first states the purpose, and the second provides critical usage constraints. It is front-loaded with essential information and appropriately sized for the tool's complexity.

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 annotations and no output schema, the description is incomplete for a mutation tool. It covers the purpose and usage constraints well but lacks details on behavioral aspects like permissions, side effects, or return values. However, it is adequate for basic understanding, aligning with a minimum viable score.

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

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

Schema description coverage is 100%, with the parameter 'request_id' well-documented in the schema. The description does not add any additional meaning or clarification about the parameter beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage.

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

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

The description clearly states the specific action ('Cancel') and resource ('a pending payment request'), distinguishing it from siblings like botwallet_cancel_payment (which likely cancels a different type of payment) and botwallet_get_paylink (which retrieves information). It precisely defines the tool's function without being tautological.

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 when to use this tool ('Only pending paylinks can be cancelled') and when not to use it ('paid or expired paylinks cannot'), providing clear context and exclusions. This directly addresses usage scenarios without needing to reference 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it indicates the tool performs a cancellation (a mutation), it lacks details on permissions required, whether the action is reversible, rate limits, error conditions (e.g., if the payment is already signed), or what happens upon success. This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence contributes essential information about the action, target, and constraints, making it 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 the tool's complexity (a mutation with no annotations and no output schema), the description is adequate but incomplete. It covers the purpose and basic usage context but lacks behavioral details like permissions, reversibility, or response format. For a cancellation tool, more context on risks or outcomes would be beneficial to fully guide 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 description coverage is 100%, with the parameter 'transaction_id' fully documented in the schema. The description does not add any additional meaning or context about the parameter beyond what the schema provides, such as format examples or where to obtain the ID. Baseline 3 is appropriate when the schema handles parameter documentation effectively.

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 specific action ('Cancel') and target resource ('a pending or pre-approved payment'), with precise scope conditions ('that has not yet been signed'). It distinguishes from sibling tools like botwallet_confirm_payment (which confirms rather than cancels) and botwallet_cancel_paylink (which cancels paylinks rather than 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 provides clear context for when to use the tool: for payments that are 'pending or pre-approved' and 'not yet signed.' However, it does not explicitly mention when NOT to use it (e.g., for already signed payments) or name alternative tools for related scenarios, such as botwallet_list_payments to find transaction IDs.

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 and does well by disclosing multiple behavioral aspects: it's a check (not an execution), shows fee/cost/balance calculations, warns about approval requirements, and warns about limit exceedances. It doesn't mention error conditions or response format details.

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

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

Two sentences with zero waste. First sentence explains what the tool does and its outputs. Second sentence provides crucial usage guidance. Every word serves a clear purpose.

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

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

For a 2-parameter tool with no annotations and no output schema, the description provides excellent context about what the tool does and when to use it. It could be slightly more complete by mentioning what happens with invalid inputs or the exact format of warnings, but it's very strong overall.

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 thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the 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 tool's purpose as a 'pre-flight check before paying' that shows fee, total cost, balance after payment, and warns about approval requirements or limit exceedances. It specifically distinguishes from sibling 'botwallet_pay' by positioning itself as a prerequisite check.

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

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

Explicitly states 'Always call this before botwallet_pay if unsure about your balance,' providing clear when-to-use guidance and naming the specific alternative tool. It establishes a clear workflow relationship between these two tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it's a write operation ('Complete a payment'), involves cryptographic signing ('FROST threshold signing'), and results in on-chain authorization. However, it doesn't mention potential side effects like transaction fees, irreversible nature, or error conditions, leaving some gaps 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 sentences with zero waste: the first states purpose and prerequisites, the second explains the technical mechanism. It's front-loaded with the core action and appropriately sized for the tool's complexity.

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 annotations and no output schema, the description does well by covering purpose, prerequisites, and technical behavior. However, as a mutation tool with cryptographic operations, it could benefit from mentioning irreversible consequences or error handling to be fully complete.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter. The description adds context by explaining where the transaction_id comes from ('from the original payment or approval event'), which provides useful semantic meaning beyond the schema's technical definition.

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 specific action ('Complete a payment'), the resource ('a payment that was previously approved'), and the mechanism ('Performs FROST threshold signing to authorize the on-chain transaction'). It distinguishes from siblings like botwallet_approval_status (check status) or botwallet_pay (initiate payment) by focusing on finalizing an already-approved transaction.

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 states when to use this tool: 'Call this after the owner approves via botwallet_events or the approval URL.' It provides clear prerequisites and distinguishes from alternatives by specifying it's for completing payments, not initiating or checking them.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: it's a write operation ('Complete'), requires prior approval, and involves 'FROST threshold signing' for on-chain authorization. However, it lacks details on permissions needed, rate limits, error conditions, or what 'complete' entails operationally (e.g., irreversible transaction).

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 zero waste: the first states purpose and prerequisite, the second adds technical context (FROST signing). Every word earns its place, and key 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 mutation tool with no annotations and no output schema, the description is moderately complete. It covers purpose, prerequisite, and technical mechanism but lacks details on permissions, side effects, return values, or error handling. Given the complexity (cryptographic signing operation), more behavioral context would be beneficial.

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 fully documents the 'transaction_id' parameter. The description adds no additional parameter semantics beyond implying it comes from 'withdrawal or approval event,' which is already covered by the schema's description. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Complete a withdrawal') and resource ('withdrawal that was previously approved by the owner'), distinguishing it from siblings like 'botwallet_withdraw' (initiate withdrawal) and 'botwallet_get_withdrawal' (retrieve withdrawal info). It provides the exact verb and scope needed for agent understanding.

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 when to use this tool: for withdrawals 'previously approved by the owner,' implying it should not be used for initiating new withdrawals or checking approval status (handled by siblings like 'botwallet_withdraw' and 'botwallet_approval_status'). However, it doesn't explicitly name alternatives or state when-not-to-use scenarios beyond the prerequisite.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns a payment URL and short code, and supports itemized invoices with auto-calculation. However, it lacks details on permissions, rate limits, error handling, or whether the paylink is publicly accessible, which are important for a creation 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 front-loaded with the core purpose and output, followed by a key feature. It consists of two efficient sentences with zero waste, making it easy to parse and understand quickly.

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

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

Given no annotations and no output schema, the description is moderately complete. It covers the purpose, output, and a key parameter interaction, but lacks details on behavioral aspects like authentication needs, side effects, or response format, which are important for a tool that creates payment requests.

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 adds some value by explaining the interaction between 'amount' and 'items' (optional if items are provided) and that the total is calculated from items, but it does not provide additional semantic context beyond what the schema 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 clearly states the specific action ('Create a payment request') and resource ('paylink'), and distinguishes it from siblings by mentioning botwallet_send_paylink as a complementary tool. It specifies the output ('payment URL and short code') and a key feature ('supports itemized invoices via the items array').

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 by stating when to use this tool ('create a payment request that someone can pay') and mentions a related tool (botwallet_send_paylink) for sending the created paylink. However, it does not explicitly state when not to use it or compare it to alternatives like botwallet_pay for direct payments.

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 mentions that setting mark_read to true marks returned events as read, indicating a side effect. However, it doesn't cover other critical behaviors such as authentication requirements, rate limits, pagination, error handling, or whether the operation is idempotent. This leaves significant gaps for a tool that likely interacts with sensitive wallet data.

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 and front-loaded, with two sentences that efficiently convey key information: the tool's purpose and a critical parameter behavior. Every word earns its place, with no redundant or vague language.

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 complexity (5 parameters, no annotations, no output schema), the description is incomplete. It covers the purpose and one behavioral aspect (mark_read) but misses details on output format, error conditions, and other behavioral traits. While the schema handles parameters well, the lack of annotations and output schema means the description should do more to guide usage in a wallet context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds value by listing example event types (e.g., approval_resolved, deposit_received) and explaining the effect of the mark_read parameter, which provides context beyond the schema's technical descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Get wallet notifications/events' specifies the verb (Get) and resource (wallet notifications/events). It lists specific event types, which helps distinguish it from siblings like botwallet_transactions or botwallet_list_payments that handle different data. However, it doesn't explicitly contrast with all siblings, keeping it from a perfect score.

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

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

The description implies usage by mentioning event types and the mark_read parameter, suggesting it's for retrieving and managing notifications. However, it lacks explicit guidance on when to use this tool versus alternatives like botwallet_pending_approvals or botwallet_list_payments, which might overlap in functionality. No exclusions or prerequisites are 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 are provided, so the description carries the full burden. It discloses that the tool returns a deposit address and a funding URL, which adds behavioral context beyond basic retrieval. However, it doesn't cover important traits like whether this is a read-only operation, if it requires authentication, rate limits, or if the address is static or dynamic per call. The description is neutral and doesn't contradict any annotations.

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

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

The description is two sentences that are front-loaded with the main action and resource, followed by additional context about usage and return values. Every sentence adds value: the first defines the core function, and the second explains the funding mechanism and extra output. There is no wasted text 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?

Given the tool has no parameters, no annotations, and no output schema, the description provides basic completeness by stating what it does and what it returns. However, for a financial tool, it lacks details on security, authentication needs, or error handling, which could be important for an AI agent. It's adequate but has clear gaps in behavioral 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?

The input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description doesn't add parameter information, which is appropriate. Baseline is 4 for 0 parameters, as it avoids unnecessary details and focuses on the tool's purpose.

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

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

The description clearly states the action ('Get') and resource ('your USDC deposit address on Solana'), specifying the cryptocurrency and blockchain. It distinguishes from siblings like 'botwallet_balance' or 'botwallet_transactions' by focusing on deposit address retrieval. However, it doesn't explicitly differentiate from all possible alternatives (e.g., 'botwallet_request_funds' might also involve funding).

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

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

The description implies usage when needing a deposit address for USDC on Solana, particularly for funding the wallet. It mentions 'Anyone can send USDC to this address to fund your wallet,' suggesting a use case. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., 'botwallet_request_funds' for requesting funds from others) or any exclusions, leaving some ambiguity.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool retrieves status and shows if paid, but lacks details on permissions required, rate limits, error handling, or what specific status information is returned (e.g., pending, completed, failed). For a read operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 and front-loaded, consisting of two clear sentences that directly state the tool's function and outcome. There is no unnecessary information or redundancy, making it efficient for an agent to parse and understand quickly.

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

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

For a tool with no annotations and no output schema, the description is moderately complete. It covers the basic purpose and parameters but lacks details on behavioral aspects like error cases, response format, or integration with sibling tools. Given the complexity of payment systems and the absence of structured output information, the description should provide more context to fully guide 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 description coverage is 100%, with both parameters ('request_id' and 'reference') documented in the schema. The description adds minimal value by implying these are identifiers for payment requests but does not clarify their relationship (e.g., if both can be used together or are alternatives). Given the high schema coverage, the baseline score of 3 is appropriate, as the description provides some context without redundant 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 tool's purpose: 'Get the status of a payment request by ID or reference. Shows if it has been paid.' It specifies the verb ('Get'), resource ('status of a payment request'), and key outcome ('Shows if it has been paid'). However, it does not explicitly differentiate from sibling tools like 'botwallet_list_paylinks' or 'botwallet_lookup', which might also retrieve payment-related information, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as whether a payment request must exist, or compare it to siblings like 'botwallet_list_paylinks' for broader queries or 'botwallet_confirm_payment' for verification. Without such context, an agent might struggle to select the correct tool in a given scenario.

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

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

No annotations are provided, so the description carries full burden. It mentions output fields (amount, fees, status, transaction hash) but omits critical behavioral details: whether this is a read-only operation, if it requires authentication, rate limits, error conditions, or how status values are defined. The description adds some context but is incomplete for safe use.

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 core purpose and key output details. Every word contributes value with no redundancy or fluff, making it easy to scan and understand quickly.

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

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

For a single-parameter lookup tool with no annotations or output schema, the description covers purpose and output fields well but lacks behavioral context (e.g., safety, auth, errors). It's minimally viable but has clear gaps that could hinder reliable agent 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?

Schema description coverage is 100%, with the parameter 'withdrawal_id' documented in the schema. The description adds no additional semantic context beyond implying it's used for lookup. Baseline 3 is appropriate as the schema handles parameter documentation 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 clearly states the specific action ('Check the status'), target resource ('withdrawal by ID'), and output details ('amount, fees, and current status', 'transaction hash'). It distinguishes from siblings like 'botwallet_withdraw' (initiate) and 'botwallet_transactions' (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 description implies usage when needing withdrawal status details, but lacks explicit guidance on when to use this versus alternatives like 'botwallet_transactions' for broader history or 'botwallet_confirm_withdrawal' for confirmation actions. No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a read-only operation ('Get wallet metadata') and specifies the scope of information returned. However, it doesn't mention potential limitations like rate limits, authentication requirements, or error conditions that would be helpful 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?

The description is perfectly concise with two sentences: the first states exactly what the tool does, the second provides crucial guidance on when to use alternatives. Every word serves a purpose, and the most important information (what the tool retrieves) 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 read operation with no output schema, the description provides excellent context about what information is returned and when to use it versus alternatives. The main gap is the lack of information about return format or structure, which would be helpful since there's no output schema. However, the description is otherwise quite complete for its purpose.

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

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

The tool has zero parameters, and schema description coverage is 100%. The description appropriately doesn't waste space discussing parameters that don't exist. A baseline of 4 is appropriate for zero-parameter tools where the schema fully documents the absence of inputs.

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 specific action ('Get wallet metadata') and enumerates the exact information retrieved (status, deposit address, owner/claim status, creation date, wallet type). It explicitly distinguishes from sibling 'botwallet_balance' by specifying what this tool does NOT provide (live on-chain balance, spending limits, remaining budget).

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 explicit guidance on when to use this tool versus alternatives: it states to use 'botwallet_balance' for live on-chain balance, spending limits, and remaining budget. This creates clear differentiation from the most relevant sibling tool and establishes appropriate usage boundaries.

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

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

No annotations are provided, so the description carries full burden. It discloses pagination behavior, which is useful, but lacks details on permissions needed, rate limits, error conditions, or what the output looks like (e.g., format of returned data). For a list operation with no annotations, this leaves significant 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 a single, efficient sentence that front-loads the core purpose and includes a key behavioral trait (pagination). Every word earns its place with no redundancy or fluff, making it 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 no annotations and no output schema, the description is minimally adequate for a list tool. It covers the purpose and pagination but lacks details on output format, error handling, or integration with siblings. For a tool with 3 parameters and full schema coverage, it's complete enough to be functional but not rich in context.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (limit, offset, status). The description adds no additional parameter semantics beyond what's in the schema, such as default values or filtering nuances. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('List') and resource ('your fund requests') with the specific scope of statuses (pending, funded, dismissed). It distinguishes from siblings like botwallet_balance or botwallet_transactions by focusing on fund requests, but doesn't explicitly differentiate from botwallet_pending_approvals or botwallet_request_funds, which might handle similar data.

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

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

No guidance on when to use this tool versus alternatives like botwallet_pending_approvals or botwallet_request_funds is provided. The description mentions pagination support, which is a technical feature but not a usage context. It lacks explicit when/when-not instructions or prerequisite information.

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 this is for viewing payment requests (not modifying them) and mentions filtering capability, but doesn't address important aspects like authentication requirements, rate limits, pagination behavior beyond the offset parameter, or what the return format looks like. The description adds some value but leaves significant behavioral questions unanswered.

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 efficiently structured with three sentences that each serve a clear purpose: stating the tool's function, explaining filtering capability, and providing sibling tool differentiation. There's no wasted text, and the most important information (what the tool does) comes first.

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 list/query tool with no annotations and no output schema, the description provides adequate context about what's being listed and how it differs from siblings. However, it doesn't address what information is returned (payment amounts, dates, identifiers) or any system constraints. The description is complete enough for basic understanding but lacks details needed for full operational understanding.

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

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

The schema has 100% description coverage, providing good documentation for all three parameters. The description adds minimal value beyond the schema by mentioning 'Filter by status' which is already covered in the schema's enum description. With high schema coverage, the baseline of 3 is appropriate as the schema does most of the parameter documentation work.

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

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

The description clearly states the specific action ('List your payment requests'), identifies the resource ('paylinks'), and explicitly distinguishes it from sibling tools ('For payments you SENT (outgoing), use botwallet_list_payments. For all money movements, use botwallet_transactions'). This provides excellent differentiation within the wallet toolset.

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 explicit guidance on when to use this tool ('requests YOU created to receive money') and when to use alternatives ('For payments you SENT... use botwallet_list_payments. For all money movements, use botwallet_transactions'). This gives clear context for tool selection among similar list/query operations.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool lists 'outgoing payment intents' and their statuses, implying a read-only operation, but it lacks details on behavioral traits like pagination behavior (beyond the offset parameter), rate limits, authentication needs, or error handling. It adds some context but is incomplete 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?

The description is two sentences with zero waste: the first sentence states the purpose and scope, and the second provides explicit usage guidance. It is front-loaded with essential information and appropriately sized.

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 moderate complexity (4 parameters, no output schema, no annotations), the description is mostly complete: it clarifies purpose, distinguishes from siblings, and implies read-only behavior. However, it lacks details on output format (e.g., what data is returned) and behavioral aspects like error handling, which would be needed for full completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add any meaning beyond what the schema provides (e.g., it doesn't explain parameter interactions or default behaviors like 'actionable' status). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('List outgoing payment intents') and resources ('payment intents and their lifecycle status'), and it explicitly distinguishes it from the sibling tool 'botwallet_transactions' by specifying this is for tracking 'specific payments you initiated' versus a 'full ledger of all money movements (in and out).'

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 explicit guidance on when to use this tool ('to track specific payments you initiated') and when to use an alternative ('For a full ledger of all money movements (in and out), use botwallet_transactions instead'), clearly differentiating it from a key sibling tool.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: it returns display name and type, and suggests similar usernames if not found. However, it lacks details on error handling, rate limits, authentication needs, or whether it's a read-only operation (implied by 'check' but not explicit).

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 appropriately sized and front-loaded, with two sentences that efficiently convey purpose, output, and fallback behavior without any wasted words 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?

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is mostly complete, covering purpose, usage context, and output behavior. However, it could benefit from mentioning authentication requirements or error cases for full completeness.

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

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

Schema description coverage is 100%, so the schema already fully documents the single 'username' parameter. The description does not add any meaning beyond what the schema provides (e.g., format examples or constraints), 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 tool's purpose with a specific verb ('Check if a recipient exists') and resource ('recipient'), distinguishing it from siblings by focusing on pre-payment validation rather than actual payment operations like 'botwallet_pay' or 'botwallet_confirm_payment'.

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 usage ('before paying'), but does not explicitly state when not to use it or name specific alternatives among the many sibling tools, such as 'botwallet_info' which might provide different recipient information.

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 effectively describes the tool as a read-only operation ('View', 'Check') that retrieves configuration data without side effects, and it hints at the context of owner-set rules, though it could add more detail on response format or error handling.

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 front-loaded with the core purpose in the first sentence and follows with a concise usage guideline, with every sentence earning its place by adding value without redundancy or unnecessary detail.

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

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

Given the tool's complexity (read-only, no parameters) and lack of annotations or output schema, the description is largely complete for its purpose. It could be slightly improved by mentioning the return format or error cases, but it adequately covers the tool's role in the context 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 tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description adds no parameter-specific information, which is appropriate since no parameters exist, but it doesn't detract from the schema's completeness.

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 with specific verbs ('View', 'Check') and resources ('guard rails', 'spending limits', 'recipient restrictions', 'earning limits', 'withdrawal rules'), distinguishing it from siblings like botwallet_balance or botwallet_info by focusing on owner-imposed restrictions rather than general wallet data.

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 explicit guidance on when to use this tool ('Check this before attempting operations that might be restricted by the owner's guard rails'), including a clear alternative action (checking limits before operations) and implicitly distinguishing it from tools like botwallet_can_i_afford or botwallet_approval_status by focusing on pre-emptive verification.

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 and does well by disclosing key behaviors: immediate completion via FROST threshold signing within guard rails, owner approval requirements returning 'needs_approval: true', and the need to check botwallet_events and call botwallet_confirm_payment for approvals. It lacks details on error handling or rate limits, but covers critical operational aspects.

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 appropriately sized and front-loaded, with the first sentence stating the purpose clearly. Each subsequent sentence adds necessary context without redundancy, though it could be slightly more streamlined in the middle section about approval flows.

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 complexity of a payment tool with no annotations or output schema, the description is quite complete. It covers purpose, usage guidelines, behavioral outcomes, and parameter semantics. It could benefit from mentioning error cases or return value details, but it provides sufficient context for effective use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantic relationship between parameters: 'Specify `to` + `amount` for direct payments, or `payment_request_id` to pay a specific paylink,' clarifying the alternative usage patterns beyond what the schema provides.

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

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

The description clearly states the action ('Make a payment') and target ('to a merchant or bot'), distinguishing it from sibling tools like botwallet_balance or botwallet_create_paylink. It specifies the core functionality with specific verbs and resources.

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 guidance is provided: 'Always call botwallet_can_i_afford first if unsure about your balance,' and it references alternatives like botwallet_events and botwallet_confirm_payment for follow-up actions. It clearly differentiates when to use this tool versus others in the workflow.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool lists pending approvals and shows approval URLs, which is useful behavioral context. However, it does not mention permissions required, rate limits, or what happens if no approvals are pending, leaving some behavioral aspects unclear.

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

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

The description is two concise sentences that front-load the purpose and follow with additional context about approval URLs. Every sentence adds value without redundancy, making it efficient 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 the tool's complexity is low (no parameters, no output schema), the description is mostly complete. It explains what the tool does and the output includes approval URLs. However, without annotations or output schema, it could benefit from more details on return format or error cases.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter information is needed. The description does not add param semantics, but this is acceptable given the lack of parameters, aligning with the baseline of 4 for 0 params.

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 'actions waiting for owner approval (payments and withdrawals)', specifying both the action type and scope. It distinguishes from siblings like botwallet_list_payments or botwallet_list_paylinks by focusing on pending approvals requiring owner 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 context ('waiting for owner approval') and mentions approval URLs for owner action, but does not explicitly state when to use this tool versus alternatives like botwallet_approval_status or botwallet_list_payments. It provides clear context but lacks explicit exclusions or named 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 effectively adds context by stating 'No authentication required' (addressing auth needs) and describing the return values ('Returns API status and version'), which are not covered by any structured fields. It does not disclose rate limits or other traits, but covers key operational aspects adequately.

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 front-loaded with the core purpose, followed by additional context in a single, efficient sentence. Every word earns its place, with no redundancy or fluff, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is mostly complete, covering purpose, authentication, and return values. However, it lacks details on error handling or specific status/version formats, which could be useful for an agent. It's adequate but has minor gaps in full contextual coverage.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, maintaining focus on the tool's purpose and behavior. This meets the baseline of 4 for tools with no parameters, as it adds value without unnecessary 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 specific action ('Check if the BotWallet API is reachable') and resource ('BotWallet API'), distinguishing it from siblings that perform operations like payments, balances, or wallet management. It directly answers what the tool does without being vague or tautological.

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 usage ('No authentication required'), indicating this is a simple connectivity check. However, it does not explicitly state when to use this tool versus alternatives (e.g., for initial setup or troubleshooting) or mention any exclusions, leaving some guidance implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing key behaviors: it creates a wallet with a 2-of-2 threshold key, specifies key share distribution (bot holds one locally, server holds the other), notes that neither share alone can sign transactions, and mentions automatic local storage ('saved to ~/.botwallet/seeds/'). However, it lacks details on permissions, 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 front-loaded with the core action and key details in three concise sentences, with no wasted words. Each sentence adds value: the first explains the registration method and key setup, the second covers the return values, and the third notes automatic storage. It is appropriately sized for the tool's complexity.

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 complexity (cryptographic wallet creation) and lack of annotations or output schema, the description is mostly complete: it explains the purpose, key behavior, and outcomes. However, it could improve by detailing the return format (e.g., structure of API key and claim code) or error scenarios, which are not covered by structured fields.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds no specific parameter information beyond what the schema provides, such as explaining how 'name' or 'owner_email' relate to the registration process. Baseline score of 3 is appropriate as the schema handles parameter semantics 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 clearly states the specific action ('Register a new bot wallet') and the method ('using FROST Distributed Key Generation'), distinguishing it from sibling tools like 'botwallet_wallet_list' or 'botwallet_wallet_import' that handle existing wallets. It specifies the resource (bot wallet) and the cryptographic setup (2-of-2 threshold key).

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

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

The description implies usage for initial wallet creation but does not explicitly state when to use this tool versus alternatives like 'botwallet_wallet_import' for importing existing wallets. It mentions the outcome (returns API key and claim code) but lacks guidance on prerequisites or exclusions, such as whether an existing wallet must not be present.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Update' implies a mutation, the description lacks details on permissions required, whether the change is reversible, potential side effects (e.g., if the name change affects linked transactions), or rate limits. It mentions the display name is shown to 'other users and in the owner portal,' adding some context, but overall, the behavioral information is insufficient for a mutation tool with zero annotation coverage.

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

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

The description is two sentences with zero waste: the first sentence states the purpose and scope, and the second provides usage guidance. It is front-loaded with the core action and efficiently conveys necessary information without redundancy, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity (a single-parameter mutation), lack of annotations, and no output schema, the description is moderately complete. It covers the purpose and usage context but lacks behavioral details like error handling or response format. For a mutation tool, this leaves gaps that could hinder an agent's ability to invoke it correctly without additional context.

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

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

Schema description coverage is 100%, with the parameter 'name' fully documented in the schema as 'New display name' with length constraints. The description does not add any additional meaning beyond this, such as examples or formatting rules (e.g., allowed characters). Since the schema handles the parameter documentation adequately, 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 states the specific action ('Update the wallet display name') and the resource ('wallet'), distinguishing it from siblings like botwallet_update_owner (which likely updates owner details) or botwallet_info (which retrieves information). It explicitly mentions what gets updated ('display name shown to other users and in the owner portal'), making the purpose unambiguous.

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

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

The description provides clear context for when to use this tool ('when you want to rebrand or clarify the bot's purpose'), which helps differentiate it from other update-related tools. However, it does not explicitly state when NOT to use it or name specific alternatives among siblings, such as botwallet_update_owner for other modifications, which prevents a perfect score.

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 that the tool sends a notification to the owner with amount and reason, which is useful behavioral context. However, it doesn't mention whether this requires owner approval, what happens after the request, or any rate limits/constraints.

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

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

Two sentences with zero waste - the first explains what the tool does, the second provides usage guidance. Every word earns its place, and the information is front-loaded appropriately.

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 2-parameter tool with no annotations and no output schema, the description provides adequate context about purpose and usage. However, it lacks information about what happens after the request (e.g., approval process, response format), which would be helpful given the mutation nature of this tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds minimal value beyond the schema by mentioning that the reason is 'shown to owner,' which slightly enhances understanding but doesn't provide significant additional semantics.

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

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

The description clearly states the specific action ('Request funds from your human owner') and resource (funds), distinguishing it from siblings like checking balance or making payments. It provides a concrete verb+resource combination that 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?

Explicitly states when to use this tool ('Use this when your balance is too low to complete a task'), providing clear context for invocation. It distinguishes this from other wallet operations by focusing on fund requests rather than transactions or queries.

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 effectively describes the core behavior (sending notifications with 'Pay Now' links) and delivery mechanisms. However, it lacks details about authentication requirements, rate limits, error conditions, or what happens if both 'to_email' and 'to_wallet' are provided, leaving important behavioral aspects 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 perfectly concise with two well-structured sentences. The first sentence establishes the purpose and usage context, while the second explains the outcome. Every word serves a purpose with zero redundancy or unnecessary elaboration.

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 4 parameters, 100% schema coverage, but no annotations or output schema, the description provides adequate but incomplete context. It covers the basic workflow and delivery methods but lacks information about return values, error handling, authentication requirements, and system constraints that would be needed for comprehensive understanding.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by implying that 'to_email' is for humans and 'to_wallet' is for agents, but doesn't provide additional semantic context about parameter interactions or usage nuances. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('send a paylink'), identifies the resource ('to a specific recipient'), and distinguishes it from sibling tools by explicitly mentioning it should be used 'after botwallet_create_paylink'. This provides a clear workflow context that differentiates it from other payment-related tools.

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

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

The description provides explicit guidance on when to use this tool ('after botwallet_create_paylink') and specifies the two delivery methods (email for humans, directly to bot wallet inbox for agents). However, it doesn't explicitly state when NOT to use it or mention alternative tools for similar functions, which prevents a perfect score.

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

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

No annotations are provided, so the description carries full burden. It describes the scope ('all completed money movements') and filtering capability ('Filter by direction'), but doesn't disclose important behavioral traits like authentication requirements, rate limits, pagination behavior beyond the schema parameters, or what the response format looks like. It adds some context but leaves gaps for a tool that presumably returns financial data.

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 perfectly concise with two sentences that each earn their place. The first sentence establishes purpose and scope, the second provides crucial sibling differentiation. No wasted words, and the most important information (what the tool does) 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?

Given no annotations and no output schema, the description provides good purpose and usage guidance but lacks details about behavioral aspects (authentication, rate limits, response format). For a financial transaction tool with 3 parameters, it's adequate but has clear gaps in operational context that would help an agent use it effectively.

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 fully documents all three parameters (limit, offset, type). The description mentions filtering by direction which aligns with the 'type' parameter, but adds no additional semantic meaning beyond what's in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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 specific action ('View the full transaction ledger') and resource ('all completed money movements including payments sent, payments received, deposits, withdrawals, fees, and refunds'). It explicitly distinguishes from sibling tool 'botwallet_list_payments' by noting this tool is for completed transactions while the sibling is for tracking outgoing payment intents by status.

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

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

The description provides explicit guidance on when to use this tool vs. alternatives: it states 'For tracking specific outgoing payment intents by status, use botwallet_list_payments instead.' This clearly defines the boundary between this tool and a key sibling, helping the agent select the right tool for the job.

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 owner receives a notification and can claim the wallet, adding some behavioral context. However, it lacks details on permissions required, whether the change is reversible, potential rate limits, or error conditions, which are important 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 concise and front-loaded, with two sentences that efficiently convey the core action and outcome. There's no unnecessary information, but it could be slightly more structured by explicitly separating purpose from effects.

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 annotations and no output schema, the description provides basic context but is incomplete. It covers the action and immediate effects (notification and claim process) but misses details like response format, error handling, or prerequisites, which are needed for a mutation tool with no structured support.

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 fully documents the 'owner_email' parameter. The description doesn't add any meaning beyond this, such as formatting examples or constraints not in the schema. Baseline 3 is appropriate when the schema handles parameter documentation 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 clearly states the action ('Set or change') and resource ('owner email for an unclaimed wallet'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'botwallet_rename' or 'botwallet_register', which might also involve wallet modifications, leaving some ambiguity about uniqueness.

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

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

The description implies usage context by specifying 'for an unclaimed wallet,' which suggests when to use this tool (i.e., only for unclaimed wallets). However, it doesn't provide explicit alternatives or exclusions, such as when not to use it (e.g., for claimed wallets) or how it differs from other wallet-related tools like 'botwallet_rename'.

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 effectively describes the tool's behavior: it reveals sensitive information (the mnemonic phrase), explains its security implications (part of a FROST 2-of-2 threshold key), and warns that possession of both shares enables transaction signing. However, it lacks details on rate limits, error conditions, or response format.

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 and well-structured: it starts with a warning emoji, states the purpose, explains the context (FROST key share), and provides usage guidelines—all in three sentences with no wasted words. Each sentence adds critical value, making it front-loaded and efficient.

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 high sensitivity and lack of annotations or output schema, the description is mostly complete. It covers purpose, security implications, and usage constraints. However, it could improve by mentioning the response format (e.g., plain text or JSON) or any prerequisites (e.g., wallet must be unlocked), leaving minor gaps.

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

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

The tool has 0 parameters, and schema description coverage is 100%. The description adds no parameter information, which is appropriate. A baseline of 4 is applied since no parameters exist, and the description compensates by explaining the tool's output (the mnemonic phrase) despite the lack of an output 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 tool's purpose: 'Reveals the 12-word mnemonic backup phrase for the current wallet.' It specifies the verb ('reveals'), resource ('mnemonic backup phrase'), and scope ('current wallet'), and distinguishes it from sibling tools like 'botwallet_wallet_export' or 'botwallet_wallet_import' by focusing on sensitive backup phrase disclosure.

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 explicit usage guidelines: 'Only use when explicitly requested by the user for backup purposes.' It also implies when not to use it (e.g., for routine operations) and distinguishes it from alternatives by highlighting its sensitive nature, which is not mentioned for other wallet-related 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 provided, the description carries the full burden of behavioral disclosure. It effectively explains key behavioral traits: the output format (.bwlt file), encryption method (AES-256-GCM), security model (server-held decryption key), and limitation (.bwlt file alone cannot unlock wallet). This covers important operational constraints beyond basic functionality.

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 perfectly concise with three tightly focused sentences that each earn their place: stating the core function, explaining the encryption mechanism, and clarifying a security limitation. No wasted words, and the most important information comes first.

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 annotations and no output schema, the description provides excellent context about the operation's behavior, security implications, and purpose. The only minor gap is not explicitly describing what happens on successful execution (e.g., file creation confirmation), but the encryption details and transfer purpose provide substantial completeness.

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

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

The input schema has 100% description coverage, clearly documenting the single 'output_path' parameter. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation when schema coverage is complete.

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 specific action ('Export the current wallet'), the resource ('to a .bwlt file'), and the purpose ('for transfer to another machine'). It distinguishes itself from siblings like botwallet_wallet_backup (which likely creates a local backup) and botwallet_wallet_import (the complementary import 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 provides clear context about when to use this tool ('for transfer to another machine') and implicitly distinguishes it from backup operations by mentioning the encryption mechanism and server-held key. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools.

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

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

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: it retrieves a decryption key from a server, decrypts wallet data, and saves data locally. However, it lacks critical details like required permissions, whether this overwrites existing wallets, error conditions, or security implications. For a tool handling sensitive wallet data with zero annotation coverage, this is insufficient.

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

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

The description is a single, well-structured sentence that efficiently explains the tool's purpose and process. It's front-loaded with the core action ('Import a wallet'), followed by key steps, with zero redundant or vague language. Every word earns its place.

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

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

Given the complexity (wallet import with decryption), lack of annotations, and no output schema, the description is moderately complete. It covers the high-level process but misses details like response format, error handling, or side effects. For a security-sensitive operation, more context would be beneficial, though the core functionality is adequately described.

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

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

The description adds meaningful context beyond the schema. While the schema (100% coverage) documents 'file_path' as a path to a .bwlt file, the description clarifies that this file is imported, decrypted using a server-retrieved key, and results in local storage of key share and config. This provides valuable semantic understanding of what the parameter enables.

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 specific action ('Import a wallet'), identifies the resource ('.bwlt file'), and distinguishes it from sibling tools like 'botwallet_wallet_export' (export) and 'botwallet_wallet_list' (list). It goes beyond the tool name by explaining the multi-step process of retrieval, decryption, and local saving.

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

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

The description implies usage when you have a .bwlt file to import, but it doesn't explicitly state when to use this tool versus alternatives like 'botwallet_register' (create new wallet) or 'botwallet_wallet_use' (switch wallets). No exclusions or prerequisites are mentioned, leaving some context gaps.

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 key behavioral traits: it's a read operation ('List', 'Shows', 'reads'), specifies the data source ('~/.botwallet/config.json'), and mentions it's shared with the CLI. It doesn't cover potential errors, permissions, or rate limits, but provides useful operational 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 efficiently structured in two sentences: the first states the core purpose and key output (default wallet), the second adds crucial implementation context (config file, CLI sharing). Every sentence adds value with zero waste.

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

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

For a zero-parameter read tool with no annotations and no output schema, the description is quite complete: it explains what it does, where data comes from, and integration context. It could be slightly improved by mentioning the output format (e.g., list of wallet objects) or error cases, but it's largely adequate.

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 0 parameters, so no parameter semantics are needed. The description appropriately focuses on what the tool does rather than inputs. With 100% schema coverage and no parameters, a baseline of 4 is justified as the description doesn't need to compensate for missing param 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?

The description clearly states the specific action ('List all locally configured wallets') and resource ('wallets'), distinguishing it from siblings like botwallet_balance (check balance) or botwallet_wallet_import (import wallet). It also adds scope details about showing the default wallet and reading from a specific config file.

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 about when to use this tool: to list locally configured wallets and identify the default. However, it doesn't explicitly state when not to use it or name alternatives (e.g., botwallet_info might provide different wallet details).

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 effectively describes the tool's effect on system state (switching the default wallet for subsequent operations) and implies a mutation (changing active wallet). However, it lacks details on permissions, error conditions, or rate limits, which would be beneficial 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 two sentences with zero waste. The first sentence states the purpose and effect, and the second provides usage guidance. It is front-loaded and efficiently 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 the tool's complexity (a mutation with no annotations and no output schema), the description is mostly complete. It explains the purpose, usage, and effect, but could improve by addressing potential errors (e.g., invalid wallet name) or confirming success. However, it adequately covers core functionality for a single-parameter tool.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'name' as 'Name of the wallet to switch to'. The description does not add any additional meaning or context beyond what the schema provides, 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 specific action ('Switch the default wallet') and resource ('wallet'), and distinguishes it from sibling tools by mentioning botwallet_wallet_list as an alternative for viewing available wallets. It precisely communicates the tool's function and scope.

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

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

The description explicitly provides when to use this tool ('Subsequent operations will use this wallet's API key and seed') and when to use an alternative ('Use botwallet_wallet_list to see available wallets'). It offers clear guidance on context 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 provided, the description carries full burden and does well by disclosing key behavioral traits: the dual-path execution (pre-approved vs. owner approval), the FROST threshold signing mechanism for immediate completions, the return value structure ('needs_approval: true'), and the asynchronous workflow requiring monitoring via botwallet_events. It doesn't mention rate limits or authentication requirements, but covers the core transactional behavior thoroughly.

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 perfectly front-loaded with the core purpose in the first clause, followed by conditional behavior and workflow guidance. Every sentence earns its place by providing essential information about execution paths and next steps without any redundant or decorative language.

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 mutation tool with no annotations and no output schema, the description does an excellent job covering the behavioral complexity (dual execution paths, asynchronous approval workflow). It could slightly improve by mentioning authentication requirements or error conditions, but it provides sufficient context for an agent to understand when and how to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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 specific action ('Withdraw USDC'), target resource ('to an external Solana address'), and distinguishes it from siblings by focusing on withdrawal functionality rather than balance checking, payments, or other wallet operations. It goes beyond a simple verb by specifying the currency (USDC) and destination 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 provides explicit guidance on when to use this tool versus alternatives: it explains the two possible outcomes (immediate completion vs. needing approval) and directs users to specific sibling tools (botwallet_events and botwallet_confirm_withdrawal) for follow-up actions. This creates clear workflow dependencies.

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 mentions the search sources and return types (API descriptions, pricing, endpoints), but lacks details on permissions, rate limits, error handling, or whether the search is real-time or cached, leaving significant gaps for a tool with potential external API calls.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose, sources, and return values without unnecessary words, making it easy to parse and understand quickly.

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

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

Given the complexity of a search tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic operation and return types, but lacks details on output format, pagination behavior, or error scenarios, which are important for effective use by an AI 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema provides, such as examples of effective queries or guidance on when to use 'catalog' vs 'bazaar', but it doesn't need to compensate for schema gaps.

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 with a specific verb ('Search') and resource ('paid APIs that accept x402 payments'), distinguishing it from siblings like 'botwallet_x402_fetch' or 'botwallet_x402_pay_and_fetch' by focusing on discovery rather than payment or data retrieval operations.

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

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

The description implies usage context by mentioning two search sources ('catalog' and 'Coinbase Bazaar directory'), but it does not explicitly state when to choose this tool over alternatives like 'botwallet_lookup' or provide clear exclusions or prerequisites for 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does an excellent job explaining key behaviors: it describes the HTTP response handling (200 returns content directly, 402 triggers payment parsing), the 'window shopping' nature (no money spent), and the output structure (returns price and fetch_id). However, it doesn't mention potential error cases, rate limits, or authentication requirements, which keeps it from a perfect 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 perfectly structured and concise. It uses three sentences that each earn their place: the first explains the core functionality, the second clarifies the 'window shopping' nature and comparison use case, and the third explicitly names the sibling tool for the next step. There's zero wasted language, and 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 tool with 4 parameters, no annotations, and no output schema, the description does an excellent job covering the essential context. It explains the tool's purpose, when to use it, key behaviors, and relationship to sibling tools. The main gap is the lack of output format details beyond mentioning 'price and a fetch_id' — without an output schema, more detail about the return structure would be helpful for a perfect score.

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

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

With 100% schema description coverage, the baseline is 3. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. While it mentions the URL parameter implicitly ('probe a URL'), it doesn't provide additional context about parameter usage, relationships, or constraints that aren't already documented in 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 the tool's purpose with specific verbs ('probe a URL', 'check if it requires x402 payment', 'parses payment requirements', 'prepares a payment intent') and resources ('URL', 'payment requirements', 'price', 'fetch_id'). It distinguishes itself from sibling tools by explaining its role in the payment flow, specifically mentioning botwallet_x402_pay_and_fetch as the next step.

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

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

The description provides explicit guidance on when to use this tool: to 'probe multiple APIs to compare prices before committing' and 'no money is spent — this is "window shopping"'. It clearly distinguishes this from the sibling botwallet_x402_pay_and_fetch, which is for actual payment, and implies it should be used before that tool. This gives clear context for when to use this tool versus 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 describes the multi-step process (FROST threshold signing, payment header building, fetching, settling) which adds valuable context beyond basic functionality. However, it lacks details on permissions, rate limits, error handling, or what 'settles' entails operationally.

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 efficiently structured in two sentences: the first states the purpose and dependency, the second details the process and return values. It is front-loaded with key information, though the second sentence is slightly dense with multiple steps concatenated.

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 complexity (multi-step payment/fetch process), no annotations, and no output schema, the description is moderately complete. It outlines the process and return values ('API response content and payment details'), but lacks details on error cases, response format, or operational constraints like authentication needs or idempotency.

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 fully documents all three parameters. The description adds marginal value by mentioning `fetch_id` comes from `botwallet_x402_fetch`, but provides no additional semantics for `headers` or `body` beyond what the schema states. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Pay for and fetch content') and identifies the resource ('x402 API'). It distinguishes from sibling tools by explicitly mentioning the dependency on `botwallet_x402_fetch` and outlining the multi-step process (FROST signing, payment header building, fetching, settling).

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 this tool: after obtaining a `fetch_id` from `botwallet_x402_fetch`. It implies usage by stating the dependency, but does not explicitly mention when NOT to use it or name alternatives among the many sibling tools (e.g., `botwallet_pay` or `botwallet_x402_discover`).

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