AurasPay Merchant MCP

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable semantic context by clarifying that the value is 'legacy', not a custodial wallet balance, and not a pricing promise — this goes beyond the structured 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 concise sentences with no fluff. The core purpose is front-loaded, and the caveat is included as a single clarifying clause. 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?

With no parameters and an existing output schema, the description only needs to clarify semantics and purpose, which it does. It could be slightly more explicit about the absence of parameters or the nature of the returned metadata, but given the provided structure, 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 has zero parameters, so there is nothing for the description to add about parameters. With 0 parameters, the baseline is 4, and the description appropriately uses no space on parameter details.

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

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

The description uses a specific verb ('Read') and names the exact resource ('account credit/plan metadata'). It also distinguishes this tool from custodial wallet or pricing tools with the caveat, setting it apart from siblings like auraspay_payment_create and auraspay_payment_get.

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 reading credit/plan metadata and warns against treating it as a wallet balance or pricing promise. However, it does not explicitly name alternative tools or state when to use them, leaving selection to inference from sibling names.

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 cover readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is well-established. The description adds that credential fields are removed, which is a meaningful behavioral disclosure beyond annotations. It doesn't describe whether the response is paginated or if there are delays due to authentication, but given the zero-parameter scope, this is adequate.

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

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

The description is two short sentences, front-loading the primary action ('Read this authenticated merchant account') before adding the credential stripping detail. Every word is essential, and there's no redundancy or filler. This is exemplary conciseness for a simple read 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?

Given the zero-parameter input, the annotations covering safety, and the presence of an output schema (which handles return structure), the description covers the essential context: what is being read, its scope, and a key data transformation (removal of credentials). It could mention that the output is a single object or reference authentication requirements, but the existing coverage is sufficient for an agent to call it correctly.

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

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

The input schema has 0 parameters, so the description doesn't need to explain parameters. The schema has 100% coverage (no parameters to cover), and the description correctly adds context by stating the resource type and the credential stripping behavior. A baseline of 4 is appropriate for a no-parameter tool where the description goes slightly beyond the bare minimum.

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

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

The description clearly states a specific verb ('read') and resource ('merchant account'), which distinguishes it from sibling tools like auraspay_account_balance or auraspay_dashboard_stats. It clarifies scope (authenticated account) and notes that credential fields are removed, which adds useful semantic detail beyond the name.

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 this is the tool to fetch the merchant's own account details, setting it apart from balance, settings, and status tools. However, it doesn't explicitly state when to prefer this over auraspay_account_balance or auraspay_merchant_setup_status, nor does it mention any prerequisites like authentication requirements. The usage context is clear but not fully 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds important behavioral context beyond those annotations by stating that the output contains masked keys and warning against revealing full credentials, which the annotations do not convey.

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

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

The description is a single compact sentence that front-loads the core purpose ('List masked merchant API keys') and adds one essential security caveat. Every word earns its place; there is no filler or repetition.

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

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

Given the tool's simplicity, zero parameters, existing output schema, and annotations that cover safety and idempotency, the description is complete. Nothing an agent needs to call this tool correctly is missing; the masked-keys warning is the only critical non-schema behavior and it is present.

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 zero parameters, there is no parameter documentation burden. The description appropriately explains the scope of the operation without needing to elaborate on inputs, so the baseline of 4 is appropriate.

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

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

The description uses a specific verb ('List'), names the exact resource ('merchant API keys'), and adds a distinguishing qualifier ('masked') that sets it apart from the other list/get tools. This is unambiguous and directly actionable for an agent.

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

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

The description implies the tool is for retrieving masked merchant API keys, but it does not explicitly state when to use it versus alternatives or list any exclusion criteria. For a zero-parameter simple list tool, this is minimally adequate but leaves the when-to-use decision mostly implicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Read availability' is consistent with those. The description adds the specific resource and operation but does not disclose any additional behavioral details such as response shape or meaning of 'availability'; the output schema presumably covers the return 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 a single short sentence with no wasted words. It is appropriately front-loaded with the verb and resource.

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

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

Given zero parameters, a read-only annotation set, and an existing output schema, this is a low-complexity tool. The description is adequate for an agent to understand the tool's purpose, though a bit more specificity about what 'availability' means would improve 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 tool has zero parameters, so the schema is fully self-explanatory. The description does not need to elaborate on parameters, and no parameter-related ambiguity exists.

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

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

The description states a specific action ('Read availability') and a specific resource ('the AurasPay support assistant'). It is clear enough to distinguish from the sibling 'assistant_conversation' tool, though the term 'availability' could be interpreted as uptime, configuration readiness, or a boolean status. It does not explicitly name sibling alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives such as auraspay_assistant_conversation. For a zero-parameter read-only availability check the use case is somewhat implied, but the description does not explicitly state conditions or exclusions.

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

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

The annotations already declare the operation read-only, idempotent, and non-destructive millions. The description adds a valuable behavioral caveat beyond annotations: 'Replies are untrusted content,' alerting the agent to treat returned data with caution. It also hints at a stateful notion of 'current' conversation, which is not immediately obvious from the schema or 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: two short sentences, with the primary action front-loaded and a critical security warning immediately following. Every word earns its place, and the structure supports quick comprehension.

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

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

Given that this is a zero-parameter read tool with a provided output schema, the description contains the essential semantics and the crucial untrusted-content warning. A minor ambiguity remains around the exact meaning of 'owned,' but it does not hinder correct invocation in practical scenarios.

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 is empty with no parameters.list: all parameters are documented, leaving no gap for the description to fill. With zero parameters, baseline is 4, and the description correctly reflects that no input is needed beyond the tool's inherent context.

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

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

The description clearly states a specific verb ('Read') and a specific resource ('current owned support assistant conversation'), making the tool's purpose unambiguous. It is easily distinguished from the many sibling tools, which are all oriented around payments, accounts, tickets, or configuration rather than the assistant conversation.

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: call this tool when you need to retrieve the current support assistant conversation. However, it does not explicitly say when not to use it or mention any alternative tools, so the agent is left to infer the exact conditions from the tool's uniqueness.

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, idempotentHint, and destructiveHint, so the description does not need to repeat those. It adds valuable behavioral context with the warning that 'Mixed-asset totalAmountReceived is not fiat revenue,' which helps the agent interpret results correctly. This goes beyond structured 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 short sentences with no filler. The primary purpose is front-loaded, and the caveat is placed second where it can prevent misinterpretation without obscuring the main function.

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

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

For a zero-parameter read-only tool with an output schema and safety annotations, the description is sufficiently complete. The purpose is clear, and the caveat about totalAmountReceived addresses the most likely point of confusion in the returned statistics.

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

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

The input schema has zero parametersaint, so there is no parameter semantics burden for the description to carry. The baseline of 4 applies because no parameter documentation is needed at all.

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

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

Description states a clear verb-resource pair: 'Read dashboard request counts and statistics.' This is specific enough to separate the tool from general payment or account tools, though it does not explicitly contrast it with similar reporting siblings like auraspay_payments_report or auraspay_payments_analyze.

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

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

There is no guidance on when to use this tool versus alternatives such as payments_report, payments_analyze, or ecosystem_overview. The read-only nature is implied by 'Read,' but no explicit context, exclusions, or alternative routing 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered and the description does not need to restate it. The description adds genuine context by warning that 'provider capability' does not mean completed KYC or issued cards — a useful semantic correction that prevents misreading the output. No contradiction with annotations, but no further behavioral detail (e.g., data freshness, aggregation scope) is disclosed.

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

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

Two sentences, both purposeful: the first front-loads the read categories in a dense list, and the second disambiguates a domain-specific term that would otherwise mislead. No filler. The second sentence's phrasing is slightly awkward ('not completed KYC or issued cards') but earns its place.

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

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

For a zero-parameter, read-only tool with full safety annotations and an output schema, the description states the covered data categories and warns about a key semantic trap. The main residual gap is scope — 'ecosystem' is never defined (all accounts vs. one workspace) — but the existing output schema likely resolves the return structure, keeping this 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 tool has zero parameters)Skip — the input schema is empty, so there is no parameter burden for the description to carry and the baseline 4 applies. The description correctly focuses on what the tool reads rather than on 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 names a specific action ('Read') and a specific resource set — receiving addresses, ownership proof status, wallet balances, and provider availability — so an agent knows exactly what data categories this overview returns. The second sentence clarifies the meaning of 'provider capability', sharpening the purpose further. It is clear and matches the tool name, but it does not explicitly differentiate itself from the 23 siblings, so it stops short of 5.

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

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

No when-to-use guidance or alternative routing is provided. With siblings like auraspay_dashboard_stats, auraspay_merchant_setup_status, and auraspay_account_balance that could plausibly overlap an 'ecosystem overview', an agent gets no help choosing among them. The only usage signal is the implicit one carried by the word 'Read' and the tool name.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description aligns with these by saying 'Read.' It adds specific behavioral context by clarifying that no tax invoice is generated, which is valuable given sibling invoice tools and reinforces the non-destructive nature.

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 deliver the core purpose and a crucial exclusion with no redundant wording. The key action is front-loaded, and the negation is placed immediately after, making the tool's scope unmistakable.

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

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

For a zero-parameter read-only tool with an output schema and strong annotations, the description covers everything needed for correct invocation. The explicit 'does not generate a tax invoice' guards against the most likely misuse, making the definition 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?

With zero parameters, the schema fully covers parameter semantics. The description adds no parameter details, but none are needed since there are no inputs to explain. Baseline of 4 applies for zero-parameter tools.

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

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

The description uses a specific verb 'Read' with a clear resource, 'platform invoice issuer settings,' and explicitly distinguishes itself from invoice generation by stating it does not generate a tax invoice. This sets it apart from sibling tools like auraspay_payment_invoice.

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

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

The description clearly states a when-not: it does not generate a tax invoice, which prevents an agent from using it for invoice creation. However, it does not explicitly name an alternative tool or provide a broader when-to-use context beyond reading settings.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds meaningful behavioral context beyond the annotations by disclosing that activity in the status is not evidence of payment success — a non-obvious semantic trap that could mislead an agent. With output schema present for return values, this is strong transparent 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?

A single sentence with the core purpose front-loaded and a valuable disambiguation clause after it. Every word earns its place; no filler, no repetition of structured data.

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

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

For a zero-parameter, read-only, fully-annotated tool with an output schema, nothing essential is missing. The description supplies the purpose and the one semantic caveat an agent needs to interpret the result correctly; return values are covered by the 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 zero parameters and 100% schema description coverage, so per rubric guidance the baseline is 4. There is nothing about parameters the description needs to clarify, and it is consistent with the empty input 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 states a specific verb ('Read') and resource ('merchant onboarding/integration lifecycle status'), clearly distinguishing this from sibling tools that deal with payments, accounts, tickets, and webhooks. The caveat 'activity is not proof of a successful payment' sharpens the semantic scope, telling the agent exactly what the status does and does not represent.

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

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

Usage context is implied rather than explicit: the tool reads a lifecycle/onboarding status, so an agent can infer when to call it. The payment caveat weakly routes away from using this as payment proof, but no alternative tool is named and no explicit when-to-use/when-not-to-use guidance is provided.

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

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

Adds substantial behavior beyond annotations: the two-step idempotent flow (reinforcing idempotentHint=true), the webhook side-effect ('may be notified when created'), and the crucial 'No funds are transferred' clarification despite readOnlyHint=false. No contradiction with annotations — the description is fully consistent with idempotentHint=true and destructiveHint=false.

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?

Four sentences, each earning its place: purpose, first-call behavior, second-call usage, and side effects. Purpose is front-loaded before workflow details. Zero fluff or redundancy, appropriately sized for a tool with a genuinely complex two-call approval workflow.

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

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

For a high-complexity tool (two-call flow, human approval, nested payment object, idempotency requirement), the description covers the essential workflow, idempotency rule, webhook side effects, and no-funds-transfer fact. An output schema exists to document return values (approvalUrl, publicUrl). Minor gap: doesn't detail what the approval process entails or error scenarios like rejection, but the critical calling sequence is fully specified.

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

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

Schema coverage is 50%, with the schema already carrying strong descriptions for key parameters: requestId ('Reuse this UUID AND identical payment details to retrieve status; never change it automatically'), network, testMode, and walletAddress. The description reinforces requestId idempotency semantics from the two-call flow but adds no new parameter-level detail for the nested payment object. With moderate schema coverage, a baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Create a shareable payment link') with a critical qualifier ('after human approval on AurasPay'). This clearly distinguishes it from siblings like auraspay_payment_get (retrieval), auraspay_payment_qr (QR generation), and auraspay_payment_invoice (invoicing). No tautology — it explains the actual function.

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

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

The description gives clear operational context with the two-call workflow: first call returns approvalUrl, second call with identical requestId returns publicUrl. This is explicit how-to-use guidance. However, it doesn't name alternative tools or state when NOT to use this tool in favor of a sibling like auraspay_payment_get, leaving differentiation to inference from the sibling list.

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, idempotentHint=true, and destructiveHint=false, so the readonly nature is covered. The description adds that only COMPLETED payments with matching fields can support reconciliation, which is useful but beyond that it doesn't reveal return format or edge cases. It doesn't contradict 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 brief and front-loads the key action (read one owned payment UUID). The second sentence adds context on reconciliation use. No fluff, but could be slightly more 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?

The output schema exists, so return values are handled. For a simple single-parameter read with helpful annotations, the description covers the core. The reconciliation context is useful, but does not mention error scenarios or what happens for non-completed payments, which could be important for reconciliation.

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 covers 100% of the parameter, including a detailed description 'Owned resource UUID, never publicId or another merchant ID.', so the description adds no parameter details beyond that. Baseline 3 is appropriate.

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

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

The description states the tool reads one owned payment UUID, which is clear. It distinguishes it from list operations by emphasizing 'one owned' and 'UUID', but doesn't explicitly differentiate from other get tools like auraspay_ticket_get. Emphasis on reconciliation is a differentiator from listing tools, but it doesn't name a sibling that does something similar.

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 this tool is for reconciliation (when authoritative data is needed), but does not explicitly state when NOT to use it or mention alternative tools (e.g., use payments_list for listing). Provides some context that it's for authoritative reads, but not enough for an agent to know it's the right choice versus other get/list 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?

Beyond the readOnlyHint and idempotentHint annotations, the description adds meaningful behavior: it returns an embedded PDF resource, performs no side effects, and requires a completed record with specific verification data. This fully informs an agent about what will and will not happen when the tool is invoked.

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 dense, front-loaded sentences with no filler. The purpose, return type, side-effect absence, and prerequisite are all included without repetition 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?

For a two-parameter, read-only, idempotent tool with an output schema, the description covers the essential context: what it generates, what it returns, what it avoids, and when it is valid to call. Nothing critical for correct invocation is missing.

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

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

Schema coverage is 0%, so the description carries the burden of explaining parameters. It indirectly describes kind via 'receipt or platform fee' and id via 'completed record with a recorded transaction and verification time', but it never explicitly names the id or kind parameters or maps them to schema properties. Partial compensation, but not 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 names a specific action (generate), a resource (completed-payment receipt or platform fee PDF), and a mechanism (existing AurasPay renderer). It also clarifies what the tool does not do (email, payment, fee collection, notification, status change), which distinguishes it from siblings like auraspay_payment_create and auraspay_payment_get.

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 it to produce a PDF receipt or fee document for a completed record, not to trigger payment or send email. It states a prerequisite (completed record with recorded transaction and verification time) and an explicit exclusion, though it does not name an alternative sibling for email or export workflows.

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, idempotentHint, and destructiveHint, and the description adds valuable behavioral context beyond that: it clarifies that the tool does not regenerate a QR, transfer funds, or confirm payment, and warns to check amount/network/recipient. This enriches the agent's understanding of side effects and safety.

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

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

Two concise sentences with zero filler. The primary action and scope are front-loaded, followed by exclusions and a safety reminder. Every sentence earns its place and the description is immediately scannable.

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 a rich output schema and safety annotations, the description is complete. It covers the action, scope, exclusions, and a caution, and the output schema handles return values. Nothing an agent needs to call it correctly 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 provides only the id parameter with format constraints but no semantic meaning. The description fills this gap by indicating the id refers to an owned payment request, giving the agent the necessary context to supply the correct identifier. With 0% schema coverage, this semantic addition is essential and well done.

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

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

The description clearly states a specific verb (Download) and a specific resource (original stored QR image for one owned payment request). It also distinguishes itself from siblings by explicitly listing what it does not do (regenerate, transfer, confirm), making it unambiguous which tool to pick.

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

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

The description implies when to use the tool (when you need the original stored QR) and includes a safety caution to verify details before paying. However, it does not explicitly name alternative tools or conditions for choosing this over auraspay_payment_get or auraspay_payment_create, so it falls slightly short of full 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 establish readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral detail beyond that: completed amounts are grouped by asset and network, never combined or converted into fiat, and the result is not all-time revenue. These are meaningful caveats an agent needs before interpreting results. 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?

Three short sentences with no filler. The core action is front-loaded, followed by two high-value clarifications that prevent misinterpretation. Every sentence earns its place.

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

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

The tool is simple, has an output schema, and annotations cover the safety profile. However, with 0% schema description coverage, the missing parameter semantics is a real gap: an agent cannot tell whether status defaults to COMPLETED or whether grouping changes when other statuses are requested. The description covers scope and currency-grouping caveats well but is not fully complete for selecting and using parameters 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 0%, so the description bears the burden of explaining page, limit, and status. It only hints at pagination with 'one page' and at status with 'Completed amounts', but it never explains how the optional status filter behaves, what the default is, or how limit/page interact. The parameter names and enum are self-evident, but the description adds almost no semantic value for the parameters.

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

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

The description states a clear verb-resource pair: 'Analyze one page of owned payments.' It adds specific scope (one page, owned payments) and explains the output shape (completed amounts grouped by asset and network). While it distinguishes itself from list/export tools, it doesn't explicitly differentiate from the similarly named 'auraspay_payments_report', so it stops short of a 5.

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

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

The description gives useful context: it is for a single page, not all-time revenue. However, it never names alternatives or states when to prefer this over payments_list, payments_report, or payments_export_csv. The 'Not all-time revenue' line implies an exclusion but does not tell the agent which sibling to use instead.

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 the operation read-only, idempotent, and non-destructive, so the description does not need to restate that. It adds behavioral value by disclosing the one-page constraint, the spreadsheet-safe formatting intent, and the pagination requirement.

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, each earning its place. The core action and output format are front-loaded, and the critical pagination caveat appears immediately after.

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 the operation is non-destructive and read-only, the description covers the key usage boundaries: single page, CSV output, pagination needed for more data. The only minor gap is not contextualizing the optional status filter, but the enum values make that reasonably self-evident.

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 0%, so the description carries the burden of explaining parameters, but it only implies page/limit through 'one page' and 'pagination.' The 'status' parameter is left entirely undocumented, and the description adds no meaning beyond the raw property names and enum values 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 states a specific verb ('Export'), a resource ('owned payments'), and an output format ('spreadsheet-safe CSV'). It also clarifies the page-limited scope, which distinguishes it from an all-time export and from sibling listing/report 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 gives clear usage guidance: export only one page and follow pagination for additional rows. It explicitly warns 'not an all-time export,' which prevents a common misuse. It does not name alternative sibling tools, but the pagination instruction is sufficient context for this export function.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate those. It adds valuable context beyond the annotations: pagination is explicit, results are scoped to 'owned' requests, and crucially, 'A request is not proof of payment'—which helps the agent avoid over-interpreting the returned 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?

Two short sentences with no filler. The core operation is front-loaded, and the caveat about payment proof is a significant addition that earns its place.

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

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

For a simple, read-only list tool with an output schema, strong annotations, and only three optional parameters, the description covers the essential scope and a key interpretive caveat. It doesn't cover status filtering semantics or when to use sibling tools, but those gaps are relatively minor given the schema and annotations.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only mentions pagination generically and does not explain the meaning of page, limit, or status, nor the implications of the status enum values.

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

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

The description uses a specific verb and resource: 'List owned payment requests,' and adds the useful note about pagination. It broadly distinguishes this from single-item or creation tools like auraspay_payment_get and auraspay_payment_create, though it doesn't name any sibling explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as auraspay_payments_analyze, auraspay_payments_export_csv, or auraspay_payment_get. The description implies a listing use case but never states exclusions, prerequisites, or when a sibling would be more appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail beyond annotations: hard bounds of 366 days and 1000 requests, explicit failure instead of silent partial totals, and a clear distinction that daily completed amounts are by network and asset, not settlement-date revenue.

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 dense sentences with no filler. The core purpose is front-loaded, and every clause adds meaningful information about bounds, filters, failure behavior, or metric semantics.

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 report-generation tool with an output schema and clear annotations, the description is complete enough. It covers scope, limits, filters, failure behavior, and the reporting basis, leaving no major operational ambiguity for an agent deciding how to call it.

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 0%, so the description must compensate. It does a good job by explaining that the date parameters form an inclusive UTC creation-date range and that status, network, and currency are filters. It does not elaborate on each parameter's format or optionality, though the schema already encodes those 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 produces a bounded report/spreadsheet-safe CSV for an inclusive UTC creation-date range, and lists the available filters. It is specific about verb and resource, but does not explicitly differentiate itself from sibling tools such as auraspay_payments_export_csv or auraspay_payments_analyze.

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 strong usage context: inclusive date range, 366-day and 1000-request limits, and filter options by status, network, or currency. It also advises narrowing the range for larger reports, but it does not explicitly state when to choose this tool over its sibling 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds non-obvious context by stating it will not download, install, execute, or claim a verified installation, which prevents an agent from over-trusting the result.

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

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

Two tight sentences: the first fronts the core behavior and resource, the second disambiguates limitations. No filler or repetition.

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

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

For a parameterless read-only listing tool with output schema and safety annotations, the description fully covers calling intent, the non-actions, and the special caveat about verified installation. Nothing needed to invoke it correctly 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 schema coverage is complete, so there is nothing for the description to add about arguments. Baseline 4 applies because no parameter documentation burden exists.

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

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

The description names the specific action ('List'), the exact resource ('official store plugin download and documentation links'), and distinguishes itself by stating what it does not do ('Does not download, install, execute a package or claim a verified installation'). This clearly separates it from the many payment/account siblings.

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

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

The description makes the core use case obvious: use it to retrieve official plugin links. It stops short of explicitly naming alternative tools or saying 'when not to use', so the routing guidance is implied rather than explicit.

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

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

Annotations already mark this as read-only and idempotent. The description adds meaningful context by noting the data is persisted and that 'Enabled' reflects user preference rather than provider availability or delivery, which is behaviorally useful beyond the annotations.

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

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

Two short sentences convey the core purpose and the most important semantic caveat. There is no filler or repetition; the description is front-loaded with the primary action and resource.

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

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

For a no-parameter read-only getter with an output schema and strong annotations, the description is complete. It explains what is read, that results reflect persisted preferences, and how to interpret the 'Enabled' field.

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 takes zero parameters, so there is no parameter documentation burden on the description. The baseline of 4 applies, and no additional parameter explanation 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 uses a specific verb ('Read') and names the resource precisely: persisted notification and display preferences. It also clarifies the meaning of 'Enabled', which disambiguates the tool from other getters and reduces misinterpretation.

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 identifies what the tool is for and the domain it covers. It does not explicitly name alternative tools or when-not-to-use conditions, but the context is clear enough for an agent to select this over unrelated sibling getters.

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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a valuable behavioral warning about testMode metadata not implying testnet, which is not present in the annotations. This extra context helps the agent correctly interpret the returned 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?

Two sentences, no redundancy, and the core purpose is front-loaded in the first sentence. The second sentence adds an essential caveat without extra verbosity. 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 zero parameters and the presence of an output schema, the description sufficiently covers the tool's purpose and an important output-interpretation caveat. It lacks no critical information for calling the tool correctly, though it could add context on typical usage scenarios, which is already reflected in the lower usage_guidelines 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 tool has zero parameters and schema coverage is 100%, so the baseline is 4 per the rubric. The description adds no parameter-specific meaning because there are no parameters to document. This is appropriate for a no-input read operation.

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

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

The description states a specific action and resource: 'Read currently supported assets and networks.' This clearly distinguishes it from the payment, account, and webhook sibling tools. Though the title is null, the verb+resource phrasing makes 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 no guidance on when to use this tool versus alternatives. The second sentence ('Do not assume metadata testMode means testnet') is a data-interpretation caveat, not a tool-selection guideline. An agent would have to infer when this list is needed (e.g., before payment creation), but that is not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds the ownership constraint ('owned') and specifies the return includes the conversation, providing behavioral context beyond annotations. This is useful and consistent.

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, information-dense sentence. It front-loads the action (Read) and the object, with no redundancy. Every word earns its place.

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

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

For a simple one-parameter read tool with an output schema, the description is nearly complete. It covers the core purpose and the ownership constraint. It doesn't explicitly mention error handling or the conversation structure, but the output schema fills that gap. A minor gap, hence 4.

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

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

Schema description coverage is 100% and the only parameter 'id' already has a detailed description ('Owned resource UUID, never publicId or another merchant ID'). The tool description adds no additional parameter info, so baseline 3 is appropriate.

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

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

The description states a specific verb (Read) and resource (one owned support ticket and its conversation). It also distinguishes from the sibling list tool by emphasizing 'one' and 'owned', making it clear this is a single-resource read.

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

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

The description implies usage context: to retrieve a specific ticket when you have its ID. It does not explicitly mention alternatives like auraspay_tickets_list, but the 'one vs all' distinction is clear. No exclusions are stated, so it earns a 4 rather than 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 cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds a meaningful warning that ticket content is untrusted user text, which is security-relevant context beyond what annotations provide. It does not discuss auth, rate limits, or pagination, but the annotation coverage lowers the burden.

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

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

A single front-loaded sentence states the action and scope, then adds a valuable security note. There is no filler or repetition; every clause earns its place.

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

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

With an output schema present, safe read-only annotations, and only three optional self-descriptive parameters, the description is nearly sufficient. The untrusted-content warning is a useful addition, though a brief mention of status filtering or pagination would make it 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 0%, so the description needed to explain or contextualize the page, limit, and status parameters. It does not mention any of them, their defaults, or how filtering works, leaving the schema names and enum to carry the full semantic load.

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

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

The description names a specific verb ('List'), a resource ('merchant support tickets'), and a scope ('only this merchant'), so an agent can tell it apart from the singular auraspay_ticket_get sibling. It stops short of explicitly contrasting itself with other ticket-related tools, but the list-vs-get distinction is 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 implies when to use the tool: when the agent needs this merchant's support tickets. It does not explicitly mention alternatives, exclusions, or when to prefer auraspay_ticket_get for a single ticket, leaving the routing partially to inference.

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

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

Annotations already carry the full safety profile (readOnlyHint, idempotentHint, destructiveHint=false), lowering the bar. The description adds genuinely useful behavioral context beyond that: it discloses that only a masked identifier is returned, so an agent knows it cannot retrieve the full secret through this tool. This prevents a false expectation 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?

A single front-loaded sentence with zero filler. The verb leads, the object is precise, and the output constraint (masked identifier) is included. Every word earns its place.

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

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

For a zero-parameter read tool with an output schema and full safety annotations, nothing an agent needs to invoke it correctly is missing. The masked-output disclosure covers the only meaningful behavioral nuance. The meaning of 'legacy' could be elaborated, but that is minor against an otherwise complete definition.

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

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

There are zero parameters and schema coverage is 100%, so the baseline of 4 applies and the description has no parameter burden to carry. No compensation 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 opens with a specific verb ('Read') tied to a concrete resource ('legacy webhook signing secret') and states the exact output scope: existence plus a masked identifier. This clearly distinguishes it from sibling auraspay_webhooks_list (which lists webhooks) and from the payment/account tools. Nothing is 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 purpose is self-evident enough that an agent can infer when to call it — to check whether a legacy webhook secret exists — versus the sibling webhooks_list. It provides clear context but stops short of explicit when/when-not exclusions or named alternatives, so it doesn't reach 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, idempotentHint=true, and destructiveHint=false, so the description doesn't need to repeat safety. It adds context about 'masked' and 'delivery metadata', indicating that endpoints are not fully revealed, which is useful. However, it doesn't disclose details like pagination or response format, but with an output schema present, that may be acceptable. 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, concise sentence with no filler. It front-loads the action 'List' and the key qualifiers 'masked' and 'delivery metadata', making it efficient for an agent to parse quickly. 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?

Given the simplicity of the tool (no parameters) and the presence of an output schema, the description covers the essential purpose. It could benefit from indicating whether the list is paginated or if there are any limits, but that is likely covered by the output schema. The description is sufficiently complete for a straightforward listing operation.

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

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

The tool has zero parameters, and schema coverage is 100% (vacuously), so the description does not need to explain parameters. Since there are no parameters, a baseline of 4 is appropriate, and the description appropriately focuses on the output content.

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

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

The description 'List masked registered webhook endpoints and delivery metadata' clearly states the action verb 'List' and the resource 'webhook endpoints' plus the key qualifier 'masked' and 'delivery metadata', distinguishing it from sibling webhook-related tool like auraspay_webhook_secret_info. It is specific and informative, though it could be more explicit about being for the 'webhooks' domain, which is already in the name.

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 listing webhook endpoints, which is a read-only operation, but does not explicitly state when to use this tool versus alternatives like auraspay_webhook_secret_info. Given the sibling named 'auraspay_webhook_secret_info', more guidance on distinguishing them would be useful, but the description's mention of 'masked' hints at a security-focused view vs. secret info.

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