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

Annotations already signal destructive and non-read-only behavior; the description adds meaningful context by stating it 'releases any held funds' and restricts applicability to pending/waiting_for_capture states. No contradiction with 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 a single, focused sentence that efficiently communicates the action, scope, and outcome with no redundant information.

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

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

For a one-parameter tool with rich annotations and an output schema, the description covers all essential behavioral context: what it does, which payment states are eligible, and the effect of releasing funds. Nothing critical is missing.

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

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

The schema already provided a complete description for payment_id ('ID of the payment to cancel'). The tool description adds no further parameter-level detail, so the schema carries the full burden, warranting a baseline score.

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

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

The description uses the specific verb 'Cancel' with the resource 'payment' and explicitly scopes to states 'pending or waiting_for_capture', clearly distinguishing it from sibling tools like capture_payment or create_refund.

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

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

Provides clear context by specifying the eligible payment states, implying when this tool should be used. However, it does not explicitly name alternatives for other states (e.g., create_refund for captured payments), so it falls short of full exclusion guidance.

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

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

Annotations already include destructiveHint=true and idempotentHint=true, and the description reinforces this with 'MOVES REAL MONEY — irreversible.' This adds significant behavioral context about financial risk beyond the annotations, making the tool's impact unmistakable.

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: one line with three short statements. Every phrase adds value, from the core action to the partial-capture option to the financial warning, with no filler.

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

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

Given the output schema exists and annotations cover safety profile, the description provides sufficient context: purpose, partial capture behavior, and irreversible financial impact. The prerequisite of a held payment is implied by 'capture held funds', making it complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, with both payment_id and amount fully documented. The description's mention of 'Optionally capture a partial amount' merely restates the schema's 'Amount for a partial capture (optional...)', adding no new meaning beyond the structured 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 explicitly states the verb 'Confirm' and specific resource 'two-step payment (capture held funds)', clearly distinguishing it from siblings like create_payment or cancel_payment. It also mentions optional partial capture, adding specificity.

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

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

The description clearly implies when to use this tool: when confirming a two-step payment and capturing held funds. It does not explicitly name alternatives or exclusion criteria, but the context is unambiguous enough for an agent to select it correctly.

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

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

The description adds critical behavioral context beyond the annotations: 'MOVES REAL MONEY (the payer is charged) — irreversible.' This strongly reinforces the destructiveHint=true annotation and warns an agent of the non-reversible, financial impact. It also discloses the return of a confirmation URL, which the agent needs to know. The description is fully consistent with the annotations.

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

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

The description is concise and front-loaded: it states the purpose in the first sentence, then returns the key output, lists supported features, and ends with a clear warning. Each sentence delivers essential information without fluff, and the warning is appropriately placed at the end for emphasis.

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

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

The description is complete given the rich schema, annotations, and output schema. It covers the main purpose, the confirmation URL, supported payment modes, and the irreversible money-movement warning. The schema handles parameter details and return values, so the description doesn't need to repeat them. For a complex payment tool, this is effectively 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 thoroughly documents all 11 parameters. The description mentions high-level features (one-step/two-step, receipts, metadata) that map to parameters but does not add new semantic meaning beyond the schema. The baseline of 3 is appropriate because the schema carries the burden.

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 verb and resource: 'Create a payment in YooKassa.' It also specifies the return of a confirmation URL and key capabilities (one-step/two-step, receipts, metadata). However, it does not differentiate from sibling tools like create_sbp_payment or create_recurring_payment, which is a minor gap.

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

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

The description implies usage as a general payment creation tool by listing supported features, but it does not explicitly state when to use this tool versus specialized siblings like create_sbp_payment or create_split_payment. There are no exclusions or alternative recommendations, so usage is implied rather than explicit.

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

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

Beyond annotations (destructiveHint=true), the description adds critical context: 'MOVES REAL MONEY — irreversible' and the asynchronous nature ('response may be pending; poll get_payout'). It also discloses the separate credentials requirement, which is not apparent from annotations or schema.

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

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

Three sentences, front-loaded with the action, then prerequisites, then behavior warning. Every sentence adds essential information with no redundancy or fluff.

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

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

Given the output schema exists and parameter coverage is complete, the description covers the essential operational context: prerequisites, async status polling, and irreversibility. It does not explain conditional parameter requirements, but the schema handles those details, making the description sufficient for this complexity.

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

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

The schema already has 100% parameter description coverage, so the baseline is 3. The description mentions recipient types (bank card, wallet, SBP) that map to the schema's destination_type enum, but it does not add new parameter-level meaning beyond what the schema already states.

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

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

The description uses a specific verb+object ('Create a payout') and clearly lists recipient types (bank card, YooMoney wallet, SBP), which distinguishes it from sibling tools like create_payment or get_payout. It immediately identifies the tool's core function without ambiguity.

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 usage context: it requires a separately-activated YooKassa Payouts product and credentials, and it instructs to poll get_payout for final status. However, it does not explicitly state when not to use this tool versus alternatives, so it stops short of a full when/when-not guide.

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

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

Annotations already disclose readOnlyHint=false and destructiveHint=true, so the description does not need to repeat those. The description adds minimal behavioral context beyond mentioning 'standalone' and the supported types. No additional side effects or requirements (like email sending) are disclosed, but with annotations present, a score of 3 is reasonable.

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

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

The description is a single, front-loaded sentence with no redundant or vague wording. Every clause contributes meaningful information, achieving maximum conciseness while remaining clear.

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

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

The tool has 10 parameters and a rich schema that fully documents them, plus annotations. The description provides a brief overview that is adequate given the schema's depth. However, it omits any reference to related tools or prerequisites (e.g., the need for payment_id or refund_id), so it is not fully complete for a tool of this complexity.

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

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

The schema covers 100% of parameters with rich per-field descriptions, so the baseline is 3. The description only mentions 'items, VAT codes, and customer contacts' as a high-level summary, which adds modest value but does not improve on the schema's detailed documentation.

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

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

The description clearly identifies the action ('Create'), the resource ('standalone fiscal receipt'), and the context (54-FZ). It distinguishes itself from sibling tools like create_payment or create_refund by focusing specifically on receipt generation, which is a distinct 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 by noting it supports both payment and refund receipts, implying when this tool is appropriate. However, it does not explicitly mention alternatives or exclusion scenarios (e.g., when to use create_refund instead of create_receipt for refunds), so it misses the top tier.

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

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

The description discloses critical behavioral traits not fully captured by annotations alone: it charges immediately, requires no user interaction, and moves real money irreversibly. The annotations already include destructiveHint=true and readOnlyHint=false, but the description enriches these with concrete financial consequences, making the risk 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?

Three short, high-impact sentences. The first states the purpose, the second describes the operational mode, and the third warns of consequences. No fluff, perfectly 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 output schema exists and annotations cover safety, the description adequately covers the essential behavioral context (immediate, no interaction, irreversible). It does not explain the 'recurring' aspect of the name, but the schema shows no recurrence parameters, so the description aligns with the actual behavior. Minor ambiguity about the tool's relationship to 'recurring' prevents 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?

The input schema has 100% coverage—every parameter has a clear description and types. The tool description adds no additional parameter-level meaning, but the schema already does the heavy lifting. Baseline 3 is appropriate.

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

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

The description begins with 'Charge a saved payment method'—a specific verb and resource that clearly states the action. The additional phrase 'immediately WITHOUT any user interaction' distinguishes it from sibling tools like create_payment or capture_payment, which might involve user-facing or multi-step flows.

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

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

The description implies when to use this tool: when a saved payment method should be charged without user interaction. This provides clear context, and the irreversibility warning helps set expectations. However, it does not explicitly name alternatives or state 'use this instead of X', so it falls short of a 5.

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

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

The description adds critical context beyond annotations: it warns that the operation moves real money and is irreversible. This enriches the destructiveHint and readOnlyHint annotations, making the financial impact unmistakable. No contradiction with 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 concise, with two sentences that are front-loaded with the action and followed by a crucial warning. Every word earns its place, and there is no redundant or vague filler.

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

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

The description covers the essential behavioral constraints (real money, irreversible, full/partial) and relies on the output schema for return values. It could be slightly more complete by mentioning prerequisites like payment status, but for a refund tool with this schema and annotations, it is sufficiently complete.

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

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

The input schema already provides descriptions for all parameters (100% coverage). The description mentions payment_id and amount by name but does not add significantly to what the schema already states. It does not elaborate on the optional description parameter or amount format.

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

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

The description clearly states a specific action: refund a payment, by payment_id and amount. It also specifies scope (full or partial) and distinguishes from sibling tools like capture_payment or cancel_payment, which are different 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 for refunds but provides no explicit guidance on when to choose this over alternatives like cancel_payment or capture_payment. There are no when-to-use or when-not-to-use statements, only an implied purpose.

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

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

Adds critical behavioral warnings: 'MOVES REAL MONEY — irreversible'—going beyond the destructiveHint annotation by emphasizing the financial impact and irreversibility. Also discloses the return of a confirmation URL/deep-link. No contradiction with annotations.

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

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

Two efficient sentences: one states the purpose, the other gives a key behavioral detail and a strong warning. No redundancy or unnecessary information.

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

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

With an output schema present, return details are covered. The description addresses core behavior (confirmation URL, irreversible money movement) but does not discuss conditional parameters like return_url required for redirect, though the schema captures that. Overall 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?

Schema description coverage is 100%, with each parameter already having a clear description. The tool description itself does not add further parameter-level meaning, so the baseline 3 applies.

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

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

The description clearly states the action ('Create a payment via SBP'), the specific resource (SBP/Russian fast payment system), and distinguishes it from sibling tools like create_payment, create_recurring_payment, and create_split_payment by focusing on SBP.

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

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

Provides clear context: this is for SBP payments and returns a confirmation URL/deep-link. However, it does not explicitly compare with alternatives (e.g., create_payment) or state when not to use this tool, so it gets a 4 rather than 5.

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

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

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description adds the critical real-world consequence 'MOVES REAL MONEY — irreversible.' This is valuable risk disclosure that strongly reinforces the destructive nature of the operation and is not redundant with the annotations.

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

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

The description is just two terse sentences, front-loaded with the action and followed by a necessary financial warning. Every word earns its place with no filler.

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

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

Given the 6-parameter schema with full descriptions and an output schema, the description supplies the essential non-schema context: marketplace purpose, product prerequisite, and financial irreversibility. It is complete for an agent to select and safely invoke the tool.

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

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

The input schema provides 100% coverage of all 6 parameters with descriptions, so the baseline is 3. The description does not add parameter-specific semantics, although it alludes to the 'transfers' parameter via 'partner shops.' The schema already handles 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 'Create a split payment for marketplaces' and specifies the exact behavior: distributing funds among partner shops. This distinguishes it from the sibling create_payment tool and other payment 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 provides clear usage context by indicating the marketplace use case and the hard prerequisite 'Requires the YooKassa-for-platforms product.' It does not explicitly name an alternative tool, but the marketplace scoping effectively tells the agent when this tool is appropriate versus create_payment.

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

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

The annotations already indicate a write operation (readOnlyHint=false) and potentially destructive behavior (destructiveHint=true). However, the description adds no additional behavioral context, such as overwrite semantics, idempotency details, or authorization requirements. It does not contradict the annotations.

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

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

The description is a single, concise sentence that front-loads the verb and object. It contains no unnecessary words or repetition.

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

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

Given the simple nature of the tool (two required parameters, both documented), the description combined with the schema is mostly complete. However, it does not specify the return value (no output schema) or clarify the destructiveHint annotation, 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 input schema fully documents both parameters (url and event) with descriptions and an enum for event. The description adds no significant parameter semantics beyond what the schema already provides, though it does mention example event types.

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

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

The description clearly identifies the action ('Register') and the resource ('webhook URL for YooKassa events'), with examples of event types. This distinguishes it from sibling tools like list_webhooks and delete_webhook.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as list_webhooks or delete_webhook, nor does it mention any prerequisites or conditions 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?

Annotations already flag destructiveHint=true and idempotentHint=true. The description adds valuable context by stating the consequence of deletion ('Stops sending notifications'), which goes beyond the schema. This helps the agent understand the side effect of the operation.

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

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

The description is exceptionally concise, with only two short sentences that convey purpose and effect. Every word earns its place—no filler or redundant information.

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

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

For a simple tool with one well-documented parameter and no output schema, the description is complete. It states what it does, the effect, and the parameter is fully described in the schema. Annotations cover the safety profile (destructive, idempotent).

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

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

The input schema provides 100% coverage with a clear description for webhook_id ('ID of the webhook to delete'). The tool description does not add additional parameter semantics, but the schema already fully explains the parameter, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Delete a webhook by ID') with a specific resource and identifier. It also differentiates from sibling tools by explicitly noting the effect ('Stops sending notifications'), making the tool's 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 usage context is clear: this tool deletes a webhook. While it doesn't explicitly mention when not to use it or name alternatives, the delete action is distinct among siblings (create, list, get webhooks), so the intended use is evident. No exclusions are stated, but none are necessary for such a straightforward deletion 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?

Annotations already declare readOnlyHint: true, so the agent knows this is a safe read operation. The description adds context about the returned fields (status, amount, etc.), but does not disclose error behavior, rate limits, or other behavioral traits beyond what annotations provide.

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

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

The description is a single declarative sentence that is front-loaded with the verb and resource, followed by a concise list of return fields. No filler or redundant content.

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

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

Given the tool's simplicity (one parameter, read-only, with output schema), the description adequately covers the purpose and expected return data. There are no obvious gaps, and the output schema can fill in detailed return types.

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 describes the only parameter payment_id with a clear description and example format (e.g., pay_xxx). The description's 'by ID' aligns with this but adds no new semantic meaning, so the baseline of 3 is appropriate given 100% 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 retrieves payment details by ID, using the specific verb 'Get' and resource 'payment details'. This distinguishes it from sibling tools like create_payment or list_payments, which perform different 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 when you have a specific payment_id and need details, but it does not explicitly state when to use it versus alternatives like list_payments, nor does it mention any exclusions. No direct comparison with sibling tools is provided.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds that it returns status, amount, and destination, which is useful, but it does not disclose error handling, pagination, or other behavioral traits. This is acceptable given the annotations.

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

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

The description is extremely concise, with two short sentences front-loading the purpose and key return fields. No unnecessary information is included, making it easy for an agent to parse quickly.

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

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

For a simple single-parameter, read-only get tool with an output schema and full parameter coverage, the description is sufficient to understand the basic function and expected return values. It omits edge cases like not-found behavior, but the overall context is adequately complete.

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

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

Schema coverage is 100% with payout_id described as 'Payout ID'. The description's 'by ID' aligns with the schema but adds no additional meaning beyond what the parameter schema already provides, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as 'payout details by ID', distinguishing it from sibling tools like get_payment or get_refund. It also lists key return fields, 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 gives clear context: use this tool to fetch payout details by ID. However, it does not explicitly name alternatives or state when not to use it, though the context alone is sufficient for a straightforward lookup 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?

Annotations already provide readOnlyHint and openWorldHint. The description adds the return fields (status, amount, payment reference), but does not disclose error behavior, auth requirements, or rate limits. This is acceptable for a simple read with annotations, but not rich.

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

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

Two short sentences, front-loaded with the action and resource. Every word contributes to clarity; there is no redundancy or filler.

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

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

For a single-parameter, read-only tool with an output schema present, the description is complete. It states the purpose and key return fields, and no additional context is necessary for an agent to use it correctly.

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

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

Schema description coverage is 100% as the schema already describes refund_id as 'Refund ID'. The description's 'by ID' adds no meaningful new semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves refund details by ID, using the specific verb 'Get' and specifying the resource. It is easily distinguished from sibling tools like create_refund and list_refunds by the 'by ID' 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 implies usage when a specific refund ID is known and details are needed. It does not explicitly exclude list_refunds for bulk retrieval or mention alternatives, but the context is clear and no misleading guidance is given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds valuable context beyond these: it specifies what the returned data represents (shop configuration, not monetary balance) and enumerates the actual fields. This prevents the agent from misinterpreting the tool as a balance/funds endpoint, which is a meaningful behavioral disclosure.

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

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

The description is two sentences, highly efficient, and front-loaded with the core information. It lists the specific fields returned in the first sentence and the important clarification in the second. Every word earns its place with no redundancy.

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

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

For a simple read-only tool with no parameters, no output schema, and rich annotations, the description is fully complete. It tells the agent exactly what information is returned and explicitly warns about what is not returned (balance). Given the low complexity, nothing important is missing.

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

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

The tool has zero parameters, and the schema is empty with 100% coverage (vacuously). The baseline for 0 parameters is 4, and the description correctly focuses on the return value rather than parameters. No parameter clarification is needed.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('shop info'), and enumerates the returned fields: ID, status, test mode, fiscalization settings. It distinguishes itself from sibling payment/refund/webhook tools by focusing on shop configuration.

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 (to retrieve shop configuration) and explicitly excludes a common misuse by noting that YooKassa has no balance endpoint. While it doesn't name alternative tools, there is no competing shop-info tool among siblings, and the clarification prevents confusion with balance-related 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?

The description goes beyond the readOnlyHint annotation by explicitly calling out the pagination cursor and filter dimensions, which tell the agent that results can be page-limited and filtered. It does not contradict the readOnlyHint; it is consistent with a read-only listing operation.

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

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

One concise, front-loaded sentence that states the verb and resource and lists the key filter dimensions without any filler. Every word contributes.

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 straightforward read-only list operation with no required parameters, the description adequately conveys what the tool does and hints at pagination via the cursor mention. However, since there is no output schema, it could benefit from a brief note about the response shape (e.g., a list of payment objects with a next_cursor).

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?

All five parameters already have complete descriptions in the schema (100% coverage), so the description adds little beyond a high-level summary of filter categories. It correctly maps status, date range, and cursor to the schema, but does not add new semantics about formats or defaults.

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

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

The description opens with the specific verb 'List' and resource 'payments', immediately identifying the operation. It adds the key attributes (status, date range, pagination cursor), which distinguishes it from payment mutation tools like create_payment/capture_payment and from list_refunds/list_receipts.

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

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

The description makes the intended use case clear: retrieving a paginated, filterable set of payments. It does not explicitly name alternatives or exclusions, but the resource name and sibling set make the boundary obvious for an agent.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds the filter capability, which is also evident from the schema, but does not disclose additional behaviors such as pagination behavior, default limit, or response format. It is consistent with annotations, so no contradiction exists.

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

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

The description is a single concise sentence that conveys the essential purpose without redundancy. It is front-loaded with the verb and resource, and every word adds value.

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

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

For a simple list tool with comprehensive schema and annotations, the description is sufficient. It names the filters and implicitly communicates the read-only nature (reinforced by annotations). The lack of an output schema is not penalized per the rules. A slightly more detailed note on pagination or use cases would improve completeness, but it is not critical for this simple tool.

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

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

Schema description coverage is 100% (all four parameters documented with descriptions). The description only repeats the filter options already present in the schema and does not add semantic meaning beyond what the schema provides. Thus, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('List') and resource ('receipts'), and specifies the filtering options ('by payment_id or refund_id'). This distinguishes it from sibling tools like list_payments or list_refunds, which target different 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?

The description implies usage contexts via the filter parameters (e.g., find receipts for a given payment), but it does not explicitly state when to use this tool over alternatives or provide exclusions. There is no mention of alternatives like list_refunds or list_payments, leaving the choice to the agent based on resource name.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds no further behavioral details (e.g., pagination, ordering). Since annotations handle the key safety context, a 3 is appropriate.

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

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

A single sentence that is direct and front-loaded with the core function. 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 list tool with two optional parameters and no output schema, the description covers the essential use case. It doesn't explicitly state the return format, but that is implicit from the name and type.

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 limit and payment_id described. The description repeats the payment_id filter but adds no new semantic meaning beyond the schema.

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

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

The description clearly states the action ('List') and resource ('refunds'), and specifies an optional filter by payment_id, distinguishing it from sibling tools like get_refund (single retrieval) and create_refund (creation).

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

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

The phrase 'with optional filter by payment_id' provides clear usage context for filtering refunds by a payment. However, it does not explicitly contrast with alternatives like list_receipts or mention when to use this over get_refund, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful context by specifying that only registered webhooks and only for this shop are included, which reinforces the read-only nature without contradicting the annotations.

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

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

A single, perfectly front-loaded sentence that conveys purpose and scope with zero wasted words. It is appropriately concise for a trivial list operation.

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?

Even without an output schema, the tool is simple: no parameters, read-only annotations, and a clear scope. The description provides all necessary context for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the description carries no parameter burden. The baseline for 0-param tools is 4, and the description fully aligns with 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 uses a specific verb ('List') and resource ('webhooks'), and specifies scope ('all registered webhooks for this shop'). This clearly distinguishes the tool from sibling tools like create_webhook and delete_webhook.

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

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

The description gives clear context by stating what is listed ('all registered webhooks') and the scope ('for this shop'). It does not explicitly mention alternatives, but the purpose is obvious enough that an agent can infer when to use this tool.

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

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

The description discloses that a small real payment is created and charged then refundable, and warns that it moves real money irreversibly. This goes beyond the annotations (which already indicate destructive hint) by explaining the mechanism and consequences, adding significant behavioral context.

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

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

The description is extremely concise with three short sentences: the purpose, the binding mechanism, and a strong irreversible warning. Every clause adds value, and the all-caps warning is impactful without unnecessary verbiage.

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

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

Given the tool's destructive nature, the description covers the essential side effect (charged then refundable) and irreversibility, aligning with annotations. It does not explain post-binding behavior or failure handling, but since an output schema is present and the operation is simple, this is 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?

All five parameters have schema descriptions covering 100%, so the tool description contributes little extra parameter semantics. It indirectly references the binding amount but does not add syntax or format details beyond what the schema already provides.

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

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

The description clearly states the tool's function: 'Save a payment method for recurring charges.' It specifies the resource (payment method) and the purpose (recurring charges), distinguishing it from sibling tools like create_payment or create_recurring_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 implies usage for binding a payment method for recurring charges, but it does not explicitly mention alternatives or when not to use it. The warning about irreversible money movement provides context, but there is no clear exclusion or comparison with other payment creation tools.

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