AurasPay Merchant MCP

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 value beyond those by warning that this is a 'legacy balance' and that the value is neither a custodial wallet balance nor a pricing promise, which is non-obvious behavioral context. 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 short sentences, with the core action front-loaded and no filler. The second sentence earns its place by clarifying the tool's scope and limitations.

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 strong annotations, the description is nearly complete. It could be more explicit about what 'credit/plan metadata' includes or why the balance is 'legacy,' but an agent has enough to select and invoke it correctly.

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

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

The tool takes zero parameters, so the baseline is 4; there is no parameter semantics to document. The description's reference to 'account credit/plan metadata' gives enough context for the no-argument call.

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

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

The description opens with a specific verb and resource: 'Read account credit/plan metadata.' It also draws a clear boundary by stating it is 'not a custodial wallet or a pricing promise,' which helps distinguish it from wallet and pricing-related siblings. It stops short of a 5 because 'legacy balance' is ambiguous and no sibling tool is named.

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

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

The description implies when to use the tool: whenever account credit/plan metadata is needed. The 'not a custodial wallet or a pricing promise' caveat tells the agent what this tool is not for, but it does not point to any alternative tool or specify conditions that would route the agent elsewhere. This is adequate but not explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds meaningful behavioral context by stating that credential fields are removed from the response, which is important security-relevant behavior 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 two short sentences with no wasted words. The core purpose is front-loaded, and the credential-removal behavior is stated in a separate, equally concise sentence.

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

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

For a parameterless, read-only tool with an output schema and strong annotations, the description is complete. It identifies the resource, confirms the read operation, and surfaces the key redaction behavior. There is no missing information an agent would need to invoke it correctly.

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

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

The tool has zero parameters, and the schema confirms no inputs are accepted. Since there are no parameters to document, the description does not need to compensate for any schema gaps, and the baseline of 4 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 states a specific verb and resource: 'Read this authenticated merchant account.' It clearly identifies the object being accessed and distinguishes this tool from siblings like balance, payments, and API key tools. The added note about credential field removal further clarifies what this account read returns.

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 'Read this authenticated merchant account' implies the tool is for retrieving the current merchant account object, so usage context is implicit. However, it does not explicitly explain when to choose this over sibling tools such as auraspay_account_balance or auraspay_preferences_get, nor does it mention any 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 description adds critical behavior beyond annotations: the key value is shown only once, never returned to the AI; existing integrations are unchanged; losing the one-time page requires revocation and re-request; and no change occurs until human approval. These are essential for an agent to set expectations. It also aligns with idempotentHint by explaining reuse of requestId.

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 with no fluff. The first sentence states the purpose, the following sentences add essential behavioral details. Each sentence earns its place, and the critical info about one-time visibility and approval is front-loaded.

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

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

The description covers the core flow: creation request, approval URL, one-time key, and retrieval via same requestId. It has an output schema, so it doesn't need to detail return values, but it does mention the URL. It lacks error handling or cancellation details, but for a tool with this complexity it's fairly complete.

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

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

Schema coverage is 0%, so the description must compensate. It mentions 'named merchant API key' which implies the name field in details, and 'Reuse the identical requestId and details' gives purpose to requestId for retrieval. However, it doesn't explain the format or constraints (UUID, maxLength) or that details only contains name. It provides some meaning but not comprehensive.

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 prepares a named merchant API key for separate human review, specifying the verb and resource. It clearly distinguishes from revocation and listing tools by focusing on creation with an approval flow. The detail about returning an approval URL further clarifies its function.

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

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

The description gives clear context: this tool is for creating API keys that require separate human approval, and it's asynchronous. However, it doesn't explicitly name alternative tools or state when not to use it. The context is sufficient for an agent to infer when to invoke it, but not as explicit as it could be.

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 well beyond the annotations by revealing the asynchronous approval flow: it returns an approval URL, makes no change until separate human approval, and requires reusing the identical requestId and details to fetch the result. This is essential behavioral context that annotations alone do not 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?

Three concise sentences deliver the purpose, the immediate consequence, the approval behavior, and the retrieval requirement. Every sentence contributes new information, and the most important facts are front-loaded. No filler or redundancy.

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

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

For a destructive, asynchronous tool, the description covers the before-state (approval required), the effect (integrations stop authenticating), and the follow-up mechanism (reuse requestId/details). With the output schema present, the description is complete enough for an agent to invoke and track the operation 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 description adds meaning by explaining that requestId and details are not just input parameters but must be reused identically to retrieve the eventual result. It also signals that the API key id must be one the caller owns. The schema already constrains formats, so the description gives the critical semantic context without repeating structure.

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 precise verb and resource: 'Revoke one owned API key'. It immediately distinguishes this from create/list operations and clearly states the consequence: 'integrations using it will stop authenticating'. There is no ambiguity about what operation is performed.

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 frames when this tool is appropriate: revoking a single owned API key when the user wants integrations to stop authenticating. It does not explicitly name alternatives or exclusions, but the scope and consequence make the usage context clear.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint=false. The description adds a meaningful behavioral guarantee—keys are masked and full credentials are never exposed—which is important security context 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?

The description is a single, direct sentence that leads with the action and immediately communicates the essential security constraint. Every word earns its place and there is no redundant phrasing.

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, an output schema, and annotations covering safety and idempotency, the description provides everything needed to invoke the tool correctly. The masking warning adds the only non-obvious behavioral detail an agent needs.

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

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

The tool has zero parameterscontinueschema coverage is complete, so there is no parameter ambiguity. The description does not need to explain parameters, and the baseline for a parameterless tool is appropriately high.

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 operation ('List'), the resource ('merchant API keys'), and a key modifier ('masked') that distinguishes it from key creation or revocation siblings. The warning against revealing full credentials adds specificity without obscuring the primary 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?

No explicit guidance is given about when to choose this tool over alternatives like auraspay_api_key_create or auraspay_api_key_revoke. The read-only, listing nature is implied but not stated in terms of use cases 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?

Annotations already convey read-only, idempotent, non-destructive behavior. The description adds the 'availability' concept but does not explain what happens when the assistant is unavailable, whether there are caveats, or how the result should be interpreted.

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

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

The description is a single clear sentence with no filler or redundant information. It is appropriately concise and immediately communicates the action and target.

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 annotations and an output schema, this description is sufficiently complete. It tells the agent exactly what action is performed, while the annotations and schema cover safety and return expectations.

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 complete, so there are no parameter semantics for the description to clarify. The baseline is 4 for such cases, and the description does not need to add parameter detail.

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

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

The description uses a specific verb ('Read') and a specific resource ('availability of the AurasPay support assistant'), making the core purpose clear. It does not explicitly distinguish itself from related assistant tools like auraspay_assistant_conversation or auraspay_assistant_message, so it misses full sibling differentiation.

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 should be used when checking whether the AurasPay support assistant is available, which is usable guidance. However, it does not state when to use this instead of the other assistant-related tools or mention any 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?

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds meaningful context by warning that replies are untrusted content, which informs how the agent should treat returned data. This is a useful behavioral disclosure 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?

A single sentence that front-loads the action and resource, with the important security caveat appended. Every word earns its place and there is no repetition of schema or annotation 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 parameterless read tool with an output schema and safety annotations, the description is complete: it says what to read, characterizes the data as untrusted, and relies on the output schema for return details. No critical operational information is missing for correct invocation.

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

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

The tool has zero parameters, so the description has no parameter obligations. The empty schema is fully covered, and the description adds no missing parameter detail; this meets the baseline for parameterless 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 states a specific verb ('Read') and a specific resource ('current owned support assistant conversation'), which clearly distinguishes it from siblings like auraspay_assistant_message and auraspay_assistant_config. The added warning about untrusted replies reinforces the read-only nature.

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 about when to call this tool versus the assistant-related siblings or any other fallback. It does not state exclusions or prerequisites, so an agent must infer usage from the name and resource.

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 idempotent and non-destructive, but the description adds substantial behavioral context: it returns an approval URL first, produces no change until human approval, refuses to send credentials or authorize actions, and requires identical requestId/details for result retrieval. This goes well beyond the structured metadata and gives an agent an accurate mental model of the tool's side-effect and async behavior.

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

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

Four dense sentences with no filler. The primary action is front-loaded, followed by important constraints and the retrieval pattern. 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 description covers the essential lifecycle: send message, receive approval URL, no change until human approval, retrieve result with the same requestId/details. Optional parameters like route, locale, and conversationId remain undocumented, but the presence of an output schema reduces the need to explain return values.

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 add meaning for requestId ('reuse the identical requestId') and attachmentId ('already-uploaded owned attachment'), and the tool's purpose implies message content. However, route, locale, and conversationId are left entirely to the schema with no added semantics, so compensation is only partial.

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 action and resource: 'Send a message to the AurasPay support assistant/provider.' This makes the core purpose immediately identifiable. It does not explicitly differentiate itself from sibling tools like auraspay_ticket_reply or auraspay_assistant_conversation, but the wording is specific enough to distinguish the general intent.

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 contextual guidance: an already-uploaded owned attachment may be included, private credentials must not be sent, and no action is authorized until separate human approval. It also explains that the same requestId and details should be reused to retrieve the result. It does not name sibling alternatives or provide explicit when-not-to-use exclusions, but the conditions are clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds an important interpretive warning that mixed-asset totalAmountReceived is not fiat revenue, which helps the agent avoid misstating results and goes 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 two sentences with no filler. The core purpose is front-loaded, followed by a single high-value caveat about the meaning of a returned statistic.

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, idempotent tool with a provided output schema and safety annotations, the description is nearly complete. The main gap is the lack of guidance on when to use it over sibling reporting tools, but that is a usage-guideline concern rather than a call-correctness one.

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 an empty input schema, so the baseline of 4 applies. There is nothing for the description to add about invocation arguments.

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 (read) and resource (dashboard request counts and statistics). It does not explicitly differentiate from sibling reporting tools, but the phrase 'dashboard request counts' is specific enough to convey the tool's 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?

No guidance is provided on when to use this tool versus the many sibling analytics/reporting tools such as auraspay_payments_report or auraspay_payments_analyze. The only usage-adjacent note is a caveat about interpreting totalAmountReceived, not a selection rule.

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' verb is consistent with those. The added clarification that provider capability is not completed KYC or issued cards provides useful domain context beyond the annotations, though it is slightly ambiguously worded.

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

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

The description is two sentences, front-loaded with the core read action and the data categories. The second sentence adds a valuable semantic caveat about provider capability, earning its place despite minor awkwardness.

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, an output schema present, and annotations covering safety/idempotency, the description is nearly complete for an overview read tool. It names all major data areas and clarifies one ambiguous concept; the output schema can handle any remaining return-value detail.

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 documentation burden. The empty schema is fully covered, and the baseline for zero-parameter tools is 4; nothing is missing here.

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

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

The description uses a specific verb ('Read') and names concrete resources: receiving addresses, ownership proof status, wallet balances, and provider availability. It is clear about what the tool returns, though it does not explicitly distinguish itself from siblings like auraspay_account_balance or auraspay_dashboard_stats.

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 broad overview/read tool by listing multiple ecosystem-level data points, but it gives no explicit when-to-use guidance or alternatives. For a zero-parameter overview tool, the implied usage is somewhat evident, but there are no exclusions or comparisons to sibling tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds the concrete clarification that no tax invoice is generated, which reinforces the read-only contract and prevents misuse, but it does not provide deeper behavioral context such as authentication needs or response characteristics. This adds modest value 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?

The description is two short sentences with no filler. The main purpose is front-loaded in the first sentence, and the second sentence meaningfully disambiguates from invoice-generation tools. 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-only tool with an output schema and rich annotations, the description is sufficient for safe and correct invocation. There are no prerequisites, parameters, or side-effect concerns that need additional explanation. The explicit negative statement also prevents a common misuse case.

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 is empty with zero parameters, so there is nothing for the description to explain about parameters. Schema coverage is trivially complete, and the baseline for zero-parameter tools is 4. The description does not need to compensate for any parameter documentation gaps.

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

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

The description states a specific verb ('Read') and resource ('platform invoice issuer settings'), making the action unambiguous. It also explicitly says 'Does not generate a tax invoice,' which distinguishes this tool from invoice-generation siblings such as auraspay_payment_invoice. This gives an agent a clear basis for selecting it.

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

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

The description implies the tool should be used for reading invoice issuer settings rather than generating invoices, but it does not explicitly name a sibling alternative or state a condition for when to choose this tool over others. The exclusion of tax-invoice generation provides indirect guidance, but the agent must infer the intended selection context.

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

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

Beyond annotations (idempotentHint, non-destructive), the description reveals the asynchronous nature: 'No change occurs until separate human approval' and 'Returns an AurasPay approval URL first'. It also instructs 'never invent a store or consent', setting an honesty constraint. The idempotency hint is operationalized by 'Reuse the identical requestId and details to retrieve the result'. This adds substantial 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 five short sentences, each delivering a distinct piece of information: purpose, honesty constraint, return behavior, approval requirement, and idempotency/retrieval. No filler or redundancy – every sentence earns its place and the critical 'Save...' verb is front-loaded.

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

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

For an async merchant-qualification tool with an output schema present, the description covers the essential workflow: what it saves, what it returns first, that no change happens until human approval, and how to retrieve the result later. It omits nothing an agent needs to call it correctly, and the output schema covers return structure.

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

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

The description does not explain the individual parameters beyond naming 'requestId' and 'details'. It says 'Reuse the identical requestId and details to retrieve the result', which gives requestId a retrieval/reuse role, but it does not describe the contents of details (platform, storeUrl, country, marketingConsent) or their expected formats. With schema_description_coverage at 0%, the description fails to compensate for parameter meaning.

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 'Save actual merchant/store onboarding details', a specific verb and resource, and adds 'Records a lifecycle event' to clarify the action's nature. It distinguishes itself from siblings like auraspay_merchant_setup_status by focusing on saving details rather than retrieving status. It also warns 'never invent a store or consent', reinforcing its real-data purpose.

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

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

The description implies when to use it: when you have actual merchant/store details to save for onboarding. It provides critical workflow context – 'Returns an AurasPay approval URL first' and 'No change occurs until separate human approval' – which tells the agent not to expect immediate changes and to handle the approval flow. It does not explicitly name alternatives or exclusions, but the context is clear enough.

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 this as a read-only, idempotent, non-destructive operation. The description adds behavioral nuance by warning that lifecycle activity is not equivalent to payment success, which helps an agent avoid misinterpreting 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?

The description is a single front-loaded sentence that states the core action first and appends only a high-value semantic caveat. 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?

With no parameters, safe read annotations, and an output schema present, the description covers everything an agent needs to invoke this tool correctly. The caveat fills the only meaningful interpretive gap.

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

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

The input schema has zero parameters, so the baseline is 4. There are no parameter semantics for the description to add, and nothing in the description contradicts 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 opens with a specific verb ('Read') and a clear resource ('merchant onboarding/integration lifecycle status'), which distinguishes it from payment, account, and wallet siblings. The added caveat about activity not proving payment success further clarifies what this status represents.

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 reading onboarding/integration lifecycle status and warns that its activity alone is not proof of a successful payment. It does not explicitly state when to prefer this over alternatives like auraspay_payment_verify, leaving the routing inferable but not explicit.

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

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

The description significantly expands on the annotations by disclosing that the first response is not a payment link, that the operation is idempotent only when requestId and payment details are identical, that merchant webhooks may be notified, and that no funds are transferred. This is consistent with idempotentHint=true and readOnlyHint=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 short sentences, each carrying essential information: creation intent, first-call result, second-call requirement, and side-effect caveat. The most important action is front-loaded in the first sentence.

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

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

For a two-step, approval-gated creation tool, the description covers the full workflow, the idempotent retry condition, webhook side effects, and the financial no-op nature. An output schema exists for return values, so the description need not describe the response structure.

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

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

The description mentions reusing the identical requestId and payment details, but this rule is already present in the requestId schema description. It does not explain the required payment subfields such as label, currency, network, or amount beyond their names and types. With roughly 50% schema description coverage, the description only partially compensates for the missing field-level guidance.

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 opens with a specific verb and resource: 'Create a shareable payment link after human approval on AurasPay.' It also names the unusual two-step behavior (approvalUrl first, publicUrl second), which distinguishes this creation flow from sibling read tools like auraspay_payment_get and auraspay_payment_qr.

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

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

It gives clear procedural direction: call once to get approvalUrl, then call again with the identical requestId and payment details after approval. This effectively states when the second call is appropriate. It does not explicitly compare against sibling tools or state when not to use it, 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 indicate readOnlyHint=true and idempotentHint=true. The description adds an important behavioral caveat: the result is only authoritative for reconciliation when the payment is COMPLETED and all specified fields match, which 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?

The description is compact and front-loaded, with the first sentence stating the core action and the second adding a relevant reconciliation constraint. The second sentence is slightly elliptic ('authoritative COMPLETED plus...'), but it earns its place as a useful caveat.

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 tool with a thorough input schema, a full output schema, and read-only/idempotent annotations, the description covers the essential context. It could be more explicit about alternatives or error cases, but nothing critical is missing for invoking the tool correctly.

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

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

Schema description coverage is 100% and the schema already explains that id is an owned resource UUID and never a publicId. The description adds no additional parameter-specific semantics beyond reinforcing the owned-UUID concept, so the baseline 3 is appropriate.

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

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

The description clearly states 'Read one owned payment UUID', specifying a concrete verb (read), resource (payment), and identifier (UUID). It implicitly distinguishes itself from list/analyze/create tools by focusing on a single owned payment, though it does not explicitly name sibling alternatives.

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

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

The description gives context by noting that only an authoritative COMPLETED payment with matching amount, asset, network, recipient, and reference can support reconciliation. However, it does not explicitly state when to choose this tool over siblings such as auraspay_payment_verify or auraspay_payments_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 mark the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral detail beyond that: it returns an embedded PDF, does not email, and does not trigger payment, fee collection, notification, or status changes. This fully clarifies the tool's side-effect profile.

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 with no filler. The core action and resource are front-loaded, and each sentence adds a distinct piece of information: what is generated, how it is returned, and what preconditions apply.

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 two-parameter tool with an output schema and clear annotations, the description is largely complete: it covers purpose, return type, side-effect absence, and prerequisites. It could be slightly more explicit about parameter-to-field mapping, but nothing essential for safe 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 description coverage is 0%, so the description must compensate for parameter meaning. It partially does: 'receipt or platform fee' maps to the kind enum, and 'completed record' implies the id refers to a completed payment record. However, it does not explicitly explain that kind selects the PDF template or that id identifies the record to render.

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

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

The description opens with a specific verb and resource: 'Generate an owned completed-payment receipt or platform fee PDF.' It further distinguishes the tool from email-sending or other reporting tools by stating it returns an embedded PDF rather than an emailed invoice, making its purpose unmistakable even among many sibling 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 context: use this when a completed-payment receipt or platform fee PDF is needed and a completed record with recorded transaction and verification time already exists. It does not explicitly name alternatives or say when not to use it, but the precondition and side-effect statement provide practical 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond this by stating it does not regenerate, transfer funds, or confirm payment, and it clarifies the 'owned payment request' scope. This provides useful context without contradicting 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 concise sentences with no filler. The main action is front-loaded, and the exclusions and safety note are delivered efficiently. Every sentence adds value.

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

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

For a simple download tool with an output schema present, the description covers the key behavioral aspects: it is read-only, idempotent, and does not affect funds. The ownership constraint and the warning to check details before paying are also included. It lacks explicit parameter guidance and error handling, but these are minor given the simplicity and existing 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 explain the 'id' parameter. The description mentions 'for one owned payment request' but never explicitly states that 'id' is the payment request ID or how to obtain it. This is a significant gap given the parameter is required and undocumented in the schema.

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

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

The description clearly states the action: 'Download the original stored QR image for one owned payment request.' It uses a specific verb and resource, and explicitly distinguishes itself from other payment operations by noting it does not regenerate, transfer, or confirm. This makes it easy for an agent to differentiate from siblings like auraspay_payment_get or auraspay_payment_verify.

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

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

The description provides clear context for when to use the tool (to download an original stored QR) and explicitly excludes other operations like regenerating, transferring funds, or confirming payment. It also includes a safety reminder to check amount, network, and recipient before paying. However, it does not name specific sibling tools to use instead, leaving some inference to the 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 establish the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral context beyond those annotations: completed amounts are grouped by asset and network, never combined or converted into fiat, and the result is specifically page-scoped rather than all-time revenue. This is meaningful insight that structured fields alone would 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?

Three short sentences, each carrying meaningful information: the primary action, the aggregation rule, and a key exclusions. The most important scoping detail is front-loaded, and 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 output schema and the read-only/idempotent annotations, the description covers the essential non-obvious behavior: page-scoped scope, grouping by asset and network, no fiat conversion, and no all-time revenue. It is sufficient for an agent to select the tool correctly, though a bit more parameter-level guidance would make invocation even safer.

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%, and the description does not directly explain the page, limit, or status parameters. 'One page' hints at the page parameter and 'Completed amounts' hints at the status parameter, but the agent is left to infer how defaults, enums, and pagination interact. This is weak compensation for the missing schema descriptions.

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

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

The description clearly identifies a specific operation: analyzing a single page of owned payments, with the explicit aggregation behavior that completed amounts are grouped by asset and network. It distinguishes itself from a plain listing tool by emphasizing grouping and non-conversion, though it does not name a specific sibling alternative.

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 the tool is appropriate: when the user wants page-scoped grouped payment amounts rather than all-time revenue. However, it does not explicitly state when to prefer this over similar tools like auraspay_payments_list, auraspay_payments_report, or auraspay_dashboard_stats, so alternatives are left 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 declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds behavioral details beyond that: it is paginated (one page per call) and produces spreadsheet-safe CSV (implying formula escaping or similar). This enriches the agent's understanding without contradicting annotations.

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

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

Two sentences, zero wasted words. The primary action and scope are front-loaded, followed by critical pagination guidance. It is appropriately sized for the tool's simplicity.

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

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

Despite having an output schema, the description is incomplete for a tool with three optional parameters. It fails to explain how to control pagination (which parameter maps to 'page'), how to set the limit, or how to filter by status. An agent would need to inspect the schema and infer semantics, which is insufficient for optimal usage.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter semantics, but it mentions none of the three parameters (page, limit, status). It does not explain how to request a specific page, set page size, or filter by status. The agent would have to rely solely on the schema's names/enums, which lack semantic 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 states a specific verb ('Export'), a specific resource ('owned payments'), the output format ('spreadsheet-safe CSV'), and a clear scope ('one page'). It also differentiates from an all-time export, which helps distinguish it from sibling tools like auraspay_payments_list or auraspay_payments_report.

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 guidance on pagination ('Follow pagination for more rows') and explicitly clarifies what this tool is not ('not an all-time export'), which sets expectations. However, it does not explicitly name alternative tools or conditions for choosing this one over siblings, leaving some inference to the 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 cover readOnlyHint and destructiveHint, so the description's main contribution is the caveat 'A request is not proof of payment.' This is valuable behavioral context beyond annotations, warning the agent that a listed request may not be a completed transaction. It also clarifies 'owned' scope, but doesn't discuss ordering, rate limits, or response details, which are acceptable given the safety 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, no filler. The purpose is front-loaded, and the caveat is a bonus. Every word earns its place, making it highly efficient for an agent to parse quickly.

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

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

Given the tool has an output schema (though not shown) and low parameter complexity (3 optional params), the description covers the core purpose, pagination, and a key caveat. It doesn't explicitly mention status filtering, but the schema does, and the description is sufficient for an agent to decide whether to use it. The only minor gap is not clarifying how pagination interacts with status, but overall it is complete enough.

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 must compensate. It mentions 'explicit pagination,' which covers page and limit, but does not explain the status filter or its enum values. The parameter names and types are self-explanatory, but the description adds no detail about filtering semantics. Since pagination is hinted but status is not, the description only partially compensates for the missing schema descriptions.

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

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

The description states a specific verb and resource: 'List owned payment requests' — clearly a listing operation scoped to owned requests. It also notes explicit pagination, which distinguishes it from single-fetch tools like auraspay_payment_get. The name and description together unambiguously convey the tool's purpose.

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

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

The description implies this is the tool for listing payment requests, but it does not explicitly contrast with siblings such as auraspay_payments_analyze, auraspay_payments_report, or auraspay_payments_export_csv. It doesn't say when to prefer this over those, nor mention filtering conditions beyond the status parameter. Guidance is implied rather than stated.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description goes well beyond this by disclosing concrete limits (max 366 days, 1000 requests), explicit failure rather than partial totals, and the accounting distinction that daily completed amounts are separated by network and asset, not settlement-date revenue. These are valuable behavioral traits not present in 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?

Three dense sentences front-load the core purpose and limits, state failure behavior, and surface the key output distinction. Every clause adds value: bounds, filters, failure mode, and semantic separation. There is no filler or irrelevant 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 read-only report with an output schema, the description covers the main elements an agent needs: purpose, limits, filters, and a key semantic warning about how daily completed amounts are grouped. It does not mention pagination or exact CSV columns, but given the output schema exists and the tool is bounded, this is a reasonable and sufficient level of completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by clarifying that startDate/endDate define an inclusive UTC creation-date range and that status, network, and currency are filters. However, it does not explicitly map each parameter to its purpose or describe format expectations beyond what the schema patterns already enforce, leaving some burden unmet.

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: 'Complete bounded report and spreadsheet-safe CSV' for payments within a date range. It clearly conveys what the tool produces and its filtering capabilities, but it does not explicitly name or contrast sibling tools such as auraspay_payments_export_csv, so it stops short of full sibling differentiation.

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: use this for bounded, inclusive UTC date-range reports with filters and explicit failure on oversized queries. It provides operational guidance ('narrow the range; no silent partial totals') but does not explicitly state when to prefer this tool over alternatives like auraspay_payments_export_csv or auraspay_payments_analyze.

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, the description discloses important behavior: the tool may update status and send notifications, returns an approval URL first, and performs no change until separate human approval. This adds meaningful async flow context that annotations alone do not convey. Slightly more detail about what 'may update status' entails could push it higher.

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 compact sentences, each earning its place: the action, the read-only alternative, the approval-URL first behavior, and the idempotent retrieval instruction. Information is front-loaded and the description is dense without being bloated.

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 core async flow, the read-only alternative, and reuse for result retrieval, and an output schema exists to define return values. A small gap is that it doesn't clarify what qualifies as an 'owned payment' or any prerequisite state, but this is not likely to block a correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for explaining requestId and details, but it only says to 'reuse the identical requestId and details'. It does not explain that details contains id and signature, what signature represents, or how these values should be obtained. This is minimal compensation for a nested two-parameter 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 a specific action ('Trigger on-chain verification for an owned payment') and distinguishes it from the read-only sibling payment_get by explicitly naming that alternative. The tool's role as a verification/approval trigger rather than a listing or creation tool is unambiguous.

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

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

It explicitly directs agents to use payment_get for read-only polling, which is a clear when-not/when-to alternative. It also explains the required workflow: the call returns an approval URL first, no change occurs until human approval, and the same requestId and details must be reused to retrieve the result.

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 read-only, idempotent, and non-destructive behavior. The description adds useful context beyond those annotations by clarifying that it does not execute packages or claim a verified installation, which sets correct expectations about the tool's side-effect-free 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?

The description is a single dense sentence that front-loads the action and resource, then lists exclusions. Every word earns its place, with no repetition of annotations 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?

With no parameters, an output schema present, and annotations covering the safety profile, the description provides everything an agent needs: what is returned, the official-store scope, and the excluded behaviors. There are no material 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 has zero properties, so schema description coverage is effectively 100% and there are no parameters to document. The zero-parameter baseline of 4 applies, and the description appropriately does not add unnecessary parameter detail.

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

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

The description uses a specific verb ('List') and a precise resource ('exact official store plugin download and documentation links'). The explicit negations distinguish it from download, install, or execution operations, and no sibling tool covers plugins, so its purpose is unambiguous.

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

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

The description clearly states what the tool will not do—download, install, execute, or verify—which helps an agent avoid using it for installation tasks. It does not name a sibling alternative, but none exists among the listed siblings, so the exclusions provide sufficient usage 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 provide readOnly, idempotent, and non-destructive hints, so the description only needs to add contextual behavior. It adds meaningful clarification that preferences are persisted and that 'enabled' reflects requested preference rather than provider availability or delivery, which is valuable 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?

The description is a single compact sentence with no filler. It front-loads the core action and resource, then adds the essential semantic caveat in a short second clause.

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

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

For a zero-parameter, read-only getter with an output schema and annotations covering safety and idempotency, this description is complete. The only potentially confusing aspect—the meaning of 'Enabled'—is explicitly addressed.

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

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

The tool has zero parameters and the schema coverage is effectively 100%, so there is no parameter detail for the description to add. The zero-parameter baseline applies, and the description appropriately avoids inventing unnecessary parameter guidance.

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 ('persisted notification and display preferences'), making the tool's purpose immediately clear. It also distinguishes itself from the sibling auraspay_preferences_update by describing a read operation rather than an update.

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 read semantics are clear and the 'enabled means requested preference' caveat helps prevent misinterpretation of results. However, the description does not explicitly state when to use this tool over alternatives or mention exclusions; usage is implied rather than directly guided.

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

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

The description discloses critical behaviors beyond the annotations: it returns an approval URL first, changes only occur after human approval, and only supplied fields are persisted. It also notes the need to reuse requestId and details. No contradiction with annotations (idempotent, non-read-only, non-destructive). It adds valuable context about the approval process.

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, all packed with essential information. The purpose is front-loaded, followed by key exclusions and the approval flow, 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?

The description covers the essential flow: approval, no immediate change, and how to retrieve the result. It doesn't explain 'native review' in detail, but the output schema presumably handles return values. For an approval-based update tool with a nested object, it provides enough guidance for correct invocation.

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

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

Schema description coverage is 0%, and the description only mentions 'requestId and details' without explaining their purpose or the subfields (theme, currency, language, etc.). It implies you can pass only the fields you want to change, but doesn't elaborate on enums or booleans. The schema is self-explanatory, but the description fails to compensate for the lack of 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 persists supplied notification/display preferences, using a specific verb ('persist') and resource ('notification/display preferences'). It distinguishes itself from siblings by noting it does not send notifications or enable missing providers and returns an approval URL, making its unique role 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 usage context: it is the update tool for preferences, and it explicitly warns about what it does not do (send notifications or enable missing providers). It also explains the approval flow and how to retrieve results, though it doesn't explicitly name the read counterpart (auraspay_preferences_get) as an alternative.

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 idempotentHint=true annotation, the description discloses that changes are staged for separate human review (not applied immediately), that certain field types are excluded, and that the same requestId retrieves the saved result. This meaningfully extends the annotation coverage with no contradiction.

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

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

Three tight sentences, each earning its place: core purpose, field exclusions, and workflow warning. The most important behavioral constraint (not submitting a new ID after uncertainty) is included without bloat.

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?

An output schema exists, so return values need no explanation. The description covers the unusual aspects of this tool — the review staging and idempotent retrieval pattern — making the call semantics clear. The main omission is what happens after human review (approval outcome, timing of effect), but the workflow-critical information 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 0% schema description coverage, the description must compensate, and it partially does: it clarifies the requestId retry semantics and negatively scopes the profile (no email, passwords, receiving wallets). However, none of the six profile sub-fields (city, name, location, phone, legalTradeName, registeredAddress) are explained in either the schema or the description, leaving a real gap.

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 ('Prepare a merchant profile change') and a distinct process ('for separate human review of before/after values'). This clearly differentiates it from a direct update or submission tool, and the field exclusions ('No email, passwords or receiving wallets') further pin down its 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 workflow guidance is clear and actionable: reuse the same requestId and profile to retrieve the saved result, and do not auto-submit a new ID after an uncertain response. It provides clear context on how to use the tool correctly, though it never names sibling alternatives or states explicit when-not-to-use conditions.

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 are minimal (readOnlyHint=false, idempotentHint=true, destructiveHint=false). The description significantly adds context: it may CREATE a referral code on first use, requires explicit approval, lists are bounded by backend limits, and it returns an approval URL first with no change until separate human approval. This goes well beyond the annotations and discloses side effects clearly. 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 dense paragraph, but every sentence adds essential information: purpose, side effect, approval flow, bounded lists, exclusions, and idempotency guidance. It is front-loaded with the main purpose and then lists caveats. Slightly long but efficient.

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

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

The tool has an output schema, so return values are covered elsewhere. The description covers side effects, approval requirements, bounded lists, and what it doesn't do. The only notable gap is parameter semantics for 'details', which is missing. Given the complexity and the existence of an output schema, the description is otherwise fairly complete.

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

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

The schema has two parameters (requestId and details) with 0% description coverage. The description mentions reusing 'the identical requestId and details' but does not explain what 'details' should contain or the format of requestId beyond what the schema provides. With zero schema coverage, the description must compensate, but it offers no parameter-level guidance.

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: 'Open this merchant referral program' and enumerates the data returned (link/code, counts, referred merchants, balances, earnings, payout history). It is clear and distinct from the 40+ sibling tools, none of which target referral programs.

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 explains when to use this tool (to open the referral program) and explicitly lists what it does NOT do (approve rewards, request a transfer, record a payout). It also instructs reusing the same requestId and details to retrieve results, which serves as a usage hint. It doesn't name alternative tools, but the exclusions provide adequate 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 declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds a valuable behavioral caveat: 'Do not assume metadata testMode means testnet,' which is beyond what annotations provide and helps prevent a common misinterpretation of output 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, each earning its place: the first states the core purpose, the second adds a crucial interpretation warning. No fluff, and the primary action is front-loaded.

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

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

This is a zero-parameter read-only tool with an output schema present and annotations covering safety. The description tells the agent what it reads and adds the testMode caveat, which is sufficient for correct invocation and interpretation. No critical information 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, so the schema trivially covers everything. The baseline for 0 parameters is 4, and the description doesn't need to add parameter details. The warning about testMode relates to output interpretation, not input semantics.

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

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

The description clearly states a specific verb ('Read') and resource ('currently supported assets and networks'). It distinguishes this tool from all siblings by its unique focus on supported tokens and networks, leaving no ambiguity about what it does.

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

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

The description implies when to use the tool (when you need the list of supported assets/networks) but provides no explicit guidance on when not to use it or which alternative to select. Since it's a unique resource, some inference is required, but no exclusions or sibling comparisons are given.

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

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

The description goes beyond annotations by disclosing that no change occurs until human approval and that an approval URL is returned first. It also hints at idempotency by instructing to reuse the same requestId and details to retrieve results. Annotations already indicate non-read-only, non-destructive, and idempotent behavior, but the description adds crucial async workflow details and security constraints, adding meaningful value.

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, delivering essential information in four short sentences. It front-loads the primary purpose, then covers security, workflow, and retrieval steps without unnecessary verbiage. Every sentence contributes directly to correct tool usage, demonstrating excellent structure and brevity.

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 core aspects: purpose, security, async approval flow, and how to retrieve results. Given the nested object structure and existing output schema, the description does not need to explain return values. It lacks explicit differentiation from sibling ticket tools, but the names and purpose are clear. The inclusion of the idempotent reuse instruction adds completeness. Overall, it is sufficient for correct invocation, though it could be slightly more explicit about when to use alternative ticket tools such as ticket_get.

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 no descriptions (0% coverage), so the description carries the burden of explaining parameters. The description mentions 'requestId' and 'details' in the context of retrieval, but does not explain the individual fields (subject, description, category, priority) or their enums. The parameter names are self-explanatory, but the lack of field-level guidance means agents must infer meaning from names alone, which is insufficient for full understanding. A score of 2 reflects that the description provides minimal parameter semantics.

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

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

The description clearly states the verb and resource: 'Create a support ticket', and adds the additional action 'notify AurasPay support'. This is specific and distinct from sibling tools like auraspay_ticket_get or auraspay_ticket_reply, which are immediately recognizable as different operations by name and description.

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

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

The description provides clear context on when to use the tool: to create a support ticket, with explicit security guidance on what not to include. It also explains the asynchronous flow (approval URL, no immediate change) and the requirement to reuse requestId and details for later retrieval. While it does not explicitly name alternative tools or state when not to use it, it offers sufficient usage context for a single-purpose creation 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, idempotentHint, and non-destructive. The description augments this by specifying that the result includes both the ticket and its conversation. It does not discuss auth or error behavior, but for a simple read operation with strong annotations this is acceptable.

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

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

A single sentence with no wasted words. It front-loads the verb and resource and includes the meaningful qualifier 'owed' plus the return scope 'and its conversation'.

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

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

For a one-parameter read-only tool with a full output schema and clear annotations, the description and schema together provide everything needed to invoke it correctly. The return shape is handled by the output schema, and the resource-ownership constraint is in the parameter description.

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

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

Schema coverage is 100% and the id parameter is already well documented with the critical constraint that it must be an owned resource UUID, not a publicId. The description's 'owned' wording aligns with this, but adds no new parameter-level detail 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 uses a specific verb ('Read') and a specific resource ('one owned support ticket and its conversation'), clearly distinguishing it from ticket creation, reply, status change, and list operations among the siblings. The 'owned' qualifier additionally narrows the scope.

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

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

The description clearly indicates this is for reading a single specific ticket rather than listing tickets, which gives the agent a clear usage context. It does not explicitly name alternatives or exclusions, but the single-item scope makes the intended use obvious against siblings like auraspay_tickets_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 cover mutation (readOnlyHint false) and idempotency (idempotentHint true). The description adds critical context: the tool returns an approval URL first and no change occurs until human approval, plus the instruction to reuse requestId and details for retrieval. This goes well beyond the annotations and clarifies the two-step execution model.

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 primary purpose, then the approval flow and idempotency instruction. No filler, every sentence adds value. Structure is clear and 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?

The tool has an output schema (not shown) which covers return values. The description covers the essential flow (approval URL, delayed change, idempotency). It does not mention ownership verification details or error conditions, but for a two-parameter tool with a clear purpose, this is nearly complete. Minor gap: how to use the approval URL after receipt.

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. It clarifies that requestId is used for retrieval and that details contains the ticket id and message, but it does not explicitly state that 'id' is the ticket identifier or describe the message field. The reuse hint adds meaning, but parameter roles are only partially explained.

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

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

States a specific verb (send), resource (support ticket), and clarifies it is an external message not a private draft. Distinct from sibling ticket tools like create, get, or set_status. The agent knows exactly what action this performs.

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 (replying to a ticket) and notes the ticket must be owned, but does not explicitly contrast with alternatives like ticket_get or ticket_set_status. No when-not-to-use guidance is provided. The approval-flow note gives context but not tool selection direction.

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 well beyond the annotations by disclosing the two-step approval workflow: 'Returns an AurasPay approval URL first' and 'No change occurs until separate human approval.' It also explains idempotent result retrieval by saying to reuse the identical requestId and details, enriching the idempotentHint annotation with concrete retrieval behavior.

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

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

Three front-loaded sentences cover purpose, the approval URL behavior, and the idempotent reuse pattern with no filler. Every sentence adds operationally relevant 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 mutating, approval-gated operation, the description covers the core workflow and idempotency semantics, and an output schema exists to describe the return shape. It is slightly incomplete only in directly mapping the requestId/details parameters to their roles in the schema.

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

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

Input schema has 0% description coverage, and the description does not formally explain details.id or details.status, though 'Close or reopen' implies status mapping and the ticket phrase implies id. It does add useful meaning by stating that requestId and details must be reused identically to retrieve the result, but the two required parameters are only minimally compensated.

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 opening clause 'Close or reopen one owned support ticket' names a specific verb, resource, and scope, making the operation immediately identifiable. It also distinguishes this from sibling ticket tools such as ticket_create, ticket_get, and ticket_reply by focusing exclusively on status mutation of an owned ticket.

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 establishes the clear usage context: this tool is for closing or reopening a ticket the caller owns. It does not explicitly name alternative tools or state when not to use it, but the 'owned' restriction and the close/reopen action provide enough context for an agent to select it among the ticket siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which covers the safety profile. The description adds valuable context by warning that ticket content is untrusted user text, a security consideration not present in annotations. This goes beyond what the structured metadata provides, warranting a 4.

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 primary action and scope. It contains no fluff and every word earns its place, making it highly efficient for an agent to parse quickly.

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

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

Given the tool has three parameters including pagination and filtering, the description provides no guidance on how they work or the expected return structure (though output schema may handle the latter). The security warning is a positive but does not compensate for missing parameter semantics and usage nuance. Overall, it is inadequate for a tool with 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 has 0% description coverage for all three parameters (page, limit, status), and the description does not elaborate on their meaning, defaults, or interaction. An agent must rely solely on names and the status enum, which is insufficient for correct invocation. The description fails to compensate for the missing schema descriptions.

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

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

The description states a clear verb ('List') and resource ('merchant support tickets') with an explicit scope ('only this merchant'), which distinguishes it from sibling tools like ticket_get or ticket_create. The added note about untrusted user text further clarifies the nature of the content, so an agent can clearly tell what this tool does.

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

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

The description implies it lists tickets scoped to the current merchant, which gives context but does not explicitly mention alternatives or when not to use it. Sibling tools like ticket_get or ticket_create exist, but no routing guidance is provided. The scoping is helpful but not a full usage guideline.

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

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

Annotations already carry readOnlyHint=false, destructiveHint=true, and idempotentHint=true. The description adds workflow behavior annotations cannot express: the two-step approval gate ('Returns an AurasPay approval URL first', 'No change occurs until separate human approval') and the idempotent-result retrieval instruction ('Reuse the identical requestId and details'). These are substantive, non-redundant disclosures and are 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?

Four short sentences, each earning its place: purpose, scope boundary, approval workflow, and retry behavior. The primary verb/resource is front-loaded and there is no filler or repetition of schema contents.

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-step destructive operation, the description covers the approval URL, the no-change-until-human-approval state, and the exact method to retrieve the outcome. With an output schema present and annotations covering mutability, destructiveness, and idempotency, 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning, and it barely does. It names 'requestId and details' only as the reuse key for retrieving results, adding no semantics about what the values mean; the enum values and UUID format remain entirely schema-borne.

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

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

States a specific verb and resource: 'Remove one previously verified payout wallet from this merchant account.' The merchant-account scope and the explicit boundary ('does not revoke access inside the wallet provider') distinguish it from the wallet ownership challenge/verify siblings and from provider-level actions.

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 implied usage context (remove a payout wallet from the merchant account) and a useful scope boundary note that provider access is not revoked. However, it names no alternative tool and provides no explicit when-to-use or when-not-to-use conditions, leaving sibling differentiation 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?

The description adds meaningful behavioral detail beyond annotations: AurasPay never receives a private key, the message is short-lived, an approval URL is returned first, and no change occurs until separate human approval. It also reinforces idempotency by instructing reuse of the same requestId and details.

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

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

Four concise sentences, each adding distinct value: purpose, security guarantee, approval flow, and idempotent retrieval. No redundancy and the key action is front-loaded.

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

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

The description covers the overall flow, prerequisites, async nature, and result retrieval without needing to explain return values thanks to the output schema. It could be improved by explicitly referencing the verify sibling, but it is largely complete for a multi-step wallet challenge.

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%, and the description does not explain the meaning of requestId, namespace, chainId, or address. It only says to reuse the identical requestId and details, which is not enough to help an agent construct correct parameter 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 identifies a specific action: 'Create a short-lived EVM or Solana ownership message.' This clearly distinguishes the tool from siblings like auraspay_wallet_ownership_verify and establishes what resource is being acted upon.

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

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

It gives useful context: 'after native review', the wallet must sign, and no change occurs until human approval. However, it never mentions when to use this tool versus auraspay_wallet_ownership_verify or other wallet-related tools, and provides no explicit 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?

Annotations indicate idempotentHint=true, and the description explicitly states 'No change occurs until separate human approval' and 'Reuse the identical requestId and details to retrieve the result,' which adds crucial behavioral context beyond annotations. This is valuable for an agent to understand the two-step nature and the need for identical parameters on retry.

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

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

The description is compact, four sentences, with the most critical information (what it does and the safety warning) front-loaded. Every sentence provides essential guidance: the action, the warning about private keys, the two-phase nature, and the idempotency requirement. No superfluous 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 has an output schema (though not shown), the description doesn't need to explain return values. It covers the critical steps: the approval URL return, the human approval requirement, and the retry mechanism. It does not explain how the payout address is saved or any prerequisites like needing an active wallet or prior challenge, but the presence of sibling tools and the challenge flow provide context. Overall, sufficiently complete for an agent to attempt a call correctly.

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

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

The schema covers 0% of parameters in descriptions, but the description explicitly mentions 'requestId' and 'details' with 'challengeId' and 'signature' implied. It adds meaning by explaining that the same requestId and details must be reused to retrieve results, which is important semantic context. However, it does not explain the exact format of the signature or encoding, which the schema partially covers via enum. Overall, it adds some value beyond the bare schema names.

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: verify a signed ownership challenge and save its payout address, which distinguishes it from related tools like auraspay_wallet_ownership_challenge. However, it does not explicitly name the sibling tool that creates the challenge, and the phrase 'after native review' is ambiguous. Overall, the verb+resource+outcome 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 provides clear guidance on when to use this tool: verify a signed challenge, and it implies that this is a follow-up to a challenge from the sibling tool. It also warns against providing private keys and mentions the need for human approval)Skip. It does not explicitly state when NOT to use it or name alternatives, but the context is sufficient 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?

The description adds significant behavioral context beyond the annotations: the secret is shown only once and never returned, no test event is sent, the tool returns an approval URL first, and no actual change occurs until human approval. These asynchronous and security behaviors are critical for an agent and are not captured by 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 dense but every sentence adds a necessary behavioral or workflow fact: approval flow, secret handling, no test event, approval URL, idempotent reuse. There is no filler, and the most important purpose is front-loaded.

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

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

Given the output schema exists and the operation is a two-parameter async registration, the description covers the full lifecycle: preparation, native review, event delivery, secret disclosure, approval URL, and retrieval via requestId. Nothing critical is missing for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by saying 'Reuse the identical requestId and details to retrieve the result,' which clarifies that both parameters act as an idempotency/correlation handle. It also implies the URL must be HTTPS from the opening phrase. Yet it does not explicitly explain the details subfields (name, url) or the purpose of requestId beyond reuse.

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 precise action and resource: 'Prepare registration of a public HTTPS webhook.' It clearly distinguishes this tool from a direct mutation by stating 'No change occurs until separate human approval,' and the sibling list shows other webhook tools (revoke, list, test) that this one is not.

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 for when to use the tool: when preparing a webhook registration that awaits native review and returns an approval URL. It also warns 'Registration sends no test event,' which helps avoid misuse. However, it does not explicitly name alternative sibling tools or state when-not-to-use beyond this.

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 indicate destructiveHint and idempotentHint, but the description adds valuable context: it returns an approval URL, no change occurs until human approval, and the same requestId/details must be reused to fetch results. This explains the destructive nature is deferred and not immediate, and illustrates the idempotent workflow. 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 four short sentences, each carrying distinct information: the action and effect, the immediate return, the approval requirement, and the result retrieval method. It is front-loaded with the core purpose and contains no filler or redundancy. 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?

For a destructive operation with an approval workflow, the description covers the essential steps: what happens (revoke), the immediate response (approval URL), the prerequisite (human approval), and how to follow up (reuse requestId/details). It does not detail the return result structure, but that is handled by the output schema. It also omits explicit mention of required parameters, but the schema covers those. Overall, it is complete enough for an agent to correctly invoke and follow through.

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 mentions 'requestId' and 'details' in the reuse guidance, implying they are used for idempotency and result retrieval, but does not explain their structure or purpose beyond that. The schema itself provides a description for 'id' (owned resource UUID, not publicId), adding some context. Overall, the description adds some meaning but not enough to fully cover the missing schema descriptions.

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

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

The description states a specific verb ('Revoke') and resource ('one owned webhook endpoint'), and clarifies the outcome ('future notifications to it stop'). It clearly distinguishes this from sibling tools like auraspay_webhook_create (creation), auraspay_webhooks_list (listing), and auraspay_webhook_test (testing), leaving no ambiguity about what this tool does.

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

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

The description provides clear context on when to use the tool (to revoke a webhook) and important procedural guidance ('Reuse the identical requestId and details to retrieve the result'). However, it does not explicitly reference alternative tools when not to use this one, nor does it mention that creation or listing should be handled by siblings. The usage context is clear but not exhaustive, missing explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read-only nature is covered. The description adds useful context beyond the annotations by specifying that the tool reports existence and returns a masked identifier, implying the full secret is not 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?

The description is a single, front-loaded sentence with no redundant words. It states the operation, the resource, and the output characteristic in an efficient manner.

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

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

This is a simple zero-parameter read-only tool with a full output schema. The description tells the agent what the tool returns (existence and masked identifier), and the annotations plus output schema cover the rest. Nothing necessary for invoking 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 an empty schema with 100% schema description coverage, so there are no parameter semantics for the description to explain. The baseline of 4 applies because the description correctly reflects that no inputs are 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 whether') and names the exact resource ('legacy webhook signing secret') as well as the key output ('masked identifier'). This clearly distinguishes it from sibling tools like auraspay_webhook_create and auraspay_webhook_revoke, which are mutation 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 its use case: checking whether a legacy webhook signing secret exists and retrieving its masked identifier. However, it does not explicitly state when to choose this over alternatives such as auraspay_webhooks_list, nor does it mention when not to use it.

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

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

The annotations already declare the operation read-only, idempotent, and non-destructive. The description adds valuable behavioral context by noting that endpoints are 'masked', telling the agent that raw or full endpoint details will not be returned, and that delivery metadata is included.

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 tight, front-loaded sentence that starts with the action and names the target resource without filler. Every word contributes meaning, and there is no repetition of the tool name or title.

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, strong safety annotations, and an output schema present, the description does not need to explain return values or input constraints. It fully conveys what the agent should expect: a listing of masked registered webhook endpoints with delivery metadata.

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

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

The tool has zero parameters, and the schema coverage is 100%, so there is no parameter documentation burden on the description. The baseline for a no-parameter tool is 4, and the description correctly provides no misleading or redundant parameter information.

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

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

The description uses a specific verb ('List') and a precise resource ('masked registered webhook endpoints and delivery metadata'), making the tool's function immediately clear. It also distinguishes itself from sibling tools like webhook_create, webhook_revoke, and webhook_secret_info by framing this as an enumeration view rather than an action or secret retrieval.

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

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

The description implies its usage: it is the tool to call when you need an overview of registered webhook endpoints and their delivery metadata. However, it does not explicitly state when not to use it or which sibling tool to prefer for alternatives, such as fetching secret details or creating a webhook.

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 rich behavioral detail beyond the annotations: signed events, receiver_accepted means HTTP 2xx only, delivery_unconfirmed is never automatically retried, no payment occurs, an approval URL is returned first, and no change happens without human approval. It reinforces the idempotentHint by instructing reuse of identical requestId and details. No contradiction with annotations is present.

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 longer than average but every sentence adds a distinct operational fact: test scope, 2xx semantics, no retries, no payment, approval flow, idempotent retrieval. It is front-loaded with the core purpose. Minor redundancy exists between 'Returns an AurasPay approval URL first' and 'No change occurs until separate human approval,' but not enough to be wasteful.

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 test-event tool with idempotent behavior and an approval flow, the description covers the essential operational contract: what is signed, what the result means, what is NOT guaranteed, how approval works, and how to retrieve the result. With an output schema present, the description does not need to describe return values in detail. It is sufficiently complete for an agent to invoke this safely and 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 must compensate. It explains requestId's role as an idempotent retrieval key ('Reuse the identical requestId and details to retrieve the result'), but it does not define what requestId is or what fields details should contain beyond the schema's own id property. The details object's meaning and structure remain largely unexplained.

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

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

The description begins with a specific verb and resource: 'Prepare one signed TEST event to an owned endpoint.' It clearly distinguishes this tool from webhook_create, payment_create, and other siblings by emphasizing TEST event, owned endpoint, and 'No payment is made.' It is unambiguous about what the tool does.

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

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

The description makes the testing context explicit ('TEST event', 'No payment is made', 'No change occurs until separate human approval') and clarifies the async result-retrieval pattern. It does not explicitly list sibling alternatives or state when not to use it, but the test-only framing provides clear contextual guidance.

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