Vaanzari Commerce

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

The description reveals only that this is a mutation ('Add') and introduces an unqualified constraint ('visible'), but it does not explain behavior like whether adding an existing saree increments quantity, whether stock availability is checked, or what side effects occur. The annotations already indicate a non-read-only mutation and no destructive hint, so the description adds little beyond them.

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 one short sentence with no filler, and the core action is front-loaded. 'Visible' is somewhat ambiguous and could use clarification, but overall the description is appropriately terse for a simple mutation tool.

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-value details are not required, but the description is otherwise thin for a tool with multiple cart-related siblings. It leaves unclear what 'visible' means, whether the saree must exist, and what happens if a duplicate is added. The parameter semantics are also incomplete.

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

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

With 0% schema description coverage, the description must compensate for the parameters. It adds some meaning by identifying saree_id as a saree, but it says nothing about quantity semantics, the default of 1, the maximum of 20, or how quantity interacts with adding to the cart. The schema provides validation details but not the conceptual 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 states a specific action ('Add'), a resource ('a visible saree'), and a destination ('customer cart'), making the tool's purpose clear. It stands apart from siblings like remove_from_cart and set_cart_quantity by its verb and object, though it does not explicitly name or differentiate them.

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 no guidance on when to use this tool versus alternatives such as set_cart_quantity or remove_from_cart. There is no stated precondition, no mention of adding a new item versus updating quantity, and no exclusion of cases where the saree is already in the cart.

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 destructive and non-idempotent behavior, and the description adds useful context about the need for signed-in browser approval and the eligibility constraint. It does not contradict the annotations and provides extra behavioral prerequisites beyond the structured metadata.

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 concise, front-loaded sentence conveys the core action, target, and prerequisite without redundant wording. Every word adds relevant meaning.

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

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

The presence of an output schema and annotations covers return values and destructive nature, and the description addresses approval and eligibility. However, it leaves undefined what makes an order 'eligible' and how the agent should verify signed-in browser approval, which is important for a destructive mutation tool.

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

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

Schema description coverage is 0%, and the description does not explain the roles of order_id, reason, or confirmation_id. The term 'eligible customer order' indirectly relates to order_id, but the description fails to compensate for the lack of parameter-level documentation.

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

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

The description states a specific action (Request cancellation), a specific resource (an eligible customer order), and a prerequisite (after signed-in browser approval). This clearly distinguishes it from sibling tools like cancel_payment_attempt by targeting orders rather than payment attempts.

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 mentioning 'eligible' and 'after signed-in browser approval', which implies when it should be used. However, it does not explicitly contrast with alternatives or state when not to use the tool, such as when an order is ineligible or approval has not been obtained.

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 destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the description's main contribution is the 'unpaid' guardrail and the 'after signed-in browser approval' precondition. It does not disclose consequences such as whether a payment hold is released or whether cancellation is irreversible, but the annotation baseline lowers the bar.

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

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

A single, front-loaded sentence with no filler. Every element—verb, resource, state, and precondition—carries meaning, and the structure makes the tool's purpose immediately scannable.

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

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

The description is adequate for an agent to know when selecting this tool and that attempt_id is the key input, especially with an output schema present. However, it leaves the optional confirmation_id undefined and does not explain how this cancellation relates to hosted-payment states or sibling resume/retry tools.

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

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

Schema description coverage is 0% and the description adds no meaning for attempt_id or confirmation_id. The optional confirmation_id is left completely unexplained, and the description does not compensate for the schema's lack of parameter documentation.

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

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

Description uses a specific verb ('Cancel'), a precise resource ('unpaid hosted payment attempt'), and a condition ('after signed-in browser approval'). It clearly distinguishes from sibling cancel_order by focusing on the payment attempt lifecycle.

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 clarifies that this applies only to unpaid hosted payment attempts and only after signed-in browser approval, which gives the agent useful selection context. However, it does not explicitly name alternatives like resume_payment or retry_payment or state when not to use it.

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

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

Annotations already convey that this is a destructive, non-read-only, idempotent operation. The description adds one useful behavioral detail: it requires signed-in browser approval. However, it does not clarify what 'close' changes, whether the action is reversible, or how the approval/confirmation_id mechanism works.

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 sentence with no filler or redundancy. It front-loads the core action and resource, and every word adds meaning.

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

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

Despite having an output schema and annotations, the description is too sparse for a destructive tool with an optional confirmation_id. It does not explain the approval flow, the meaning or requirement of confirmation_id, or the post-close behavior, leaving an agent without enough context to invoke the tool correctly in nuanced situations.

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, but it does not explain either parameter. 'Support ticket' weakly implies ticket_id identifies the ticket, but confirmation_id is completely unexplained and its relationship to 'signed-in browser approval' is left ambiguous.

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

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

The description clearly identifies the action (close), the resource (customer support ticket), and a precondition (signed-in browser approval). It is not a tautology and is distinguishable from sibling tools like create_support_ticket or reply_support_ticket, though it does not explicitly name those 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 phrase 'after signed-in browser approval' gives some contextual guidance about when this tool is appropriate, but it does not explicitly explain when to use it instead of related tools such as reply_support_ticket or cancel_order. No exclusions or alternative routing are provided.

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

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

It discloses an important behavioral requirement beyond the annotations: signed-in browser approval is needed before the ticket is created. This meaningfully informs the agent that user interaction and authentication approval are required, even though the annotations themselves do not carry this 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 one tight sentence that front-loads the core action and includes the critical browser-approval prerequisite. There is no redundant restatement of the title or unnecessary filler.

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

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

For a tool with four parameters, two required, and zero parameter descriptions, the definition is thin. It does not explain the optional order_id and confirmation_id usage, possible behavior if browser approval is denied, or how the created ticket is returned. The presence of an output schema helps, but the surrounding context is still under-specified.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters, but it mentions none. Property names like subject, message, order_id, and confirmation_id are somewhat self-explanatory, but the description does not clarify which fields are required, how they relate, or when the optional identifiers should be supplied.

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

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

The description uses a specific verb and resource: 'Create a customer support ticket.' It clearly identifies this as the tool for opening a new ticket, distinguishing it from siblings like reply_support_ticket, close_support_ticket, and list_support_tickets without ambiguity.

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

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

The description gives a clear operating condition: the ticket must be created after signed-in browser approval, which tells the agent this is not an unattended operation. It does not explicitly name alternatives or exclusions, but the creation intent is unambiguous given the sibling set.

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 'authorized' and 'customer' context, indicating this is the authenticated user's own profile, but it does not disclose potential error conditions or access constraints beyond that.

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 five-word sentence that front-loads the action ('Read') and resource. Every word earns its place with no redundant or filler 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?

A zero-parameter, read-only operation with an output schema and safety annotations needs little else. The description specifies exactly which resource is read and under whose authorization, making it fully complete for an agent to invoke correctly.

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

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

The tool has zero parameters, so the schema fully covers semantics by construction. The baseline for 0 parameters is 4, and the description correctly avoids adding irrelevant 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') with a specific resource ('authorized customer account profile'), clearly distinguishing it from sibling getters like get_artisan or get_order. The 'authorized' qualifier also clarifies it targets the caller's own account, not any arbitrary one.

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

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

The description implies usage when the agent needs the current customer's account profile, but it does not explicitly mention alternatives or when not to use it. Given the large sibling list of getters and account-related tools, a short routing statement would improve selection confidence.

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 the safety profile: readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds only that the profile is 'public', which implies non-public profiles are out of scope, a useful behavioral constraint. No additional context like not-found behavior is given, but the bar is lower thanks to 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 seven-word sentence that is front-loaded with the action and resource. No filler or redundancy. The brevity means some useful context is omitted, so it is concise but not fully informative.

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 one required parameter, an existing output schema, and annotations covering safety, the description is nearly adequate. The main gaps are explicit id semantics and usage guidance, but for a simple read tool these are relatively minor and partly inferable.

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 schema provides only the parameter name 'id' with a pattern and length constraints. The description does not explicitly explain that 'id' is the artisan's identifier, though the tool name and 'artisan profile' make this easy to infer. It adds minimal meaning beyond the property name.

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

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

The description states a specific verb ('Get') and resource ('one public Vaanzari artisan profile'). The word 'one' clearly distinguishes this from the sibling list_artisans, and 'public' narrows the scope, so an agent can tell what it does without confusion.

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

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

Usage is implied by the singular 'one' — you call this when you need a specific artisan profile rather than a list — but there is no explicit when-to-use, when-not-to-use, or alternative naming as seen in higher-quality definitions.

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, so the safety profile is fully covered. The description adds the 'current totals' detail, which hints at return content, but offers no additional behavioral context such as caching, freshness, or relationship to checkout.

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 filler. Every word earns its place, quickly conveying both the operation and the returned 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 strong annotations and an output schema, the description is sufficient for selection and invocation. No critical behavioral or usage 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?

With zero parameters, the schema is trivially complete. The description does not need to explain parameters, and none are listed. This matches the baseline for a parameterless tool.

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 resource ('customer cart') and adds 'current totals' to clarify the returned data. It clearly distinguishes this read-only cart operation from cart mutation siblings like add_to_cart and remove_from_cart.

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-only nature and cart scope imply when to use the tool, but it does not explicitly distinguish itself from get_checkout_summary, which may also surface totals. No exclusion or alternative guidance is provided.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds useful behavioral nuance by saying it 'revalidates' checkout data and explicitly does not place an order, which goes slightly beyond the generic annotation hints.

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 filler. It communicates the core action, scope, and side-effect boundary efficiently.

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

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

With an output schema and strong annotations, the description does not need to explain return values or safety. However, it lacks explicit routing guidance against sibling tools and leaves the optional parameters only minimally described, so it is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely references 'discounts' and 'points'. It does not explain how coupon_code and points_to_redeem are applied, whether they are independent or interactive, or what validation semantics apply.

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

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

The description names a specific verb ('Revalidate') and a clear resource scope (cart, discounts, points, addresses, checkout total), and explicitly excludes order placement. This clearly distinguishes it from order-placing siblings like start_checkout.

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 'without placing an order' implies this is a pre-checkout validation/preview tool, but the description does not explicitly explain when to use it instead of related siblings such as get_cart, validate_coupon, or start_checkout. The use case is implied, not stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds the 'authorized' qualifier, indicating authentication/authorization behavior, but doesn't explain what happens for unauthorized requests or whether the order must belong to the current customer. Some useful context beyond annotations, but limited.

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 filler. It covers the resource and a key behavioral scope ('authorized') in very few words. Efficient and easy to parse.

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

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

For a simple one-parameter read tool with a rich annotation set and an output schema present, the description is mostly sufficient. The main missing element is routing guidance relative to list_orders or other order-related siblings, but the core invocation context is clear 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 description coverage is 0%, and the description does not explain order_id at all. The parameter name is self-explanatory, but the description adds no guidance on format, source, or semantics beyond what the schema's type and pattern already provide. With low schema coverage, the description should compensate and does not.

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: 'Get one authorized customer order.' The singular 'one' differentiates it from list_orders, and 'authorized customer order' clarifies scope. However, it does not explicitly name or contrast with sibling tools like list_orders or get_cart, so it slightly 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 phrasing 'get one authorized customer order' implies use when fetching a single order by ID, versus listing orders. But there is no explicit when-to-use guidance, no mention of alternatives, and no exclusions. Usage context 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds modest value by specifying 'latest provider status', implying temporal freshness and an external provider source, but does not discuss error behavior or unknown attempt IDs. 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?

A single sentence that is front-loaded with the key verb and resource. Every word earns its place, and there is no filler or repetition of the schema.

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

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

Given a simple one-parameter tool, rich annotations, and an output schema that can document return fields, the description is nearly complete. It could add explicit guidance about invalid attempt IDs or the distinction from cancellation/retry, but it already provides enough for correct invocation in most cases.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented attempt_id. It adds domain meaning by identifying the attempt as a 'customer payment attempt', but it does not explain where attempt_id comes from, how to format it, or what 'latest' means relative to retries. This is minimal but non-tautological compensation.

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'), a specific resource ('latest provider status'), and the scope ('a customer payment attempt'). This clearly distinguishes it from mutation siblings like retry_payment and cancel_payment_attempt, and from other reads like get_order or get_checkout_summary.

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 verb 'Read' provides clear context that this tool is for status retrieval, not for modifying or resuming a payment. It does not explicitly name alternatives or exclusions, but the purpose statement makes the intended usage obvious given the sibling tool names.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds only the 'saved' qualifier, which indicates persistent state but does not disclose return format, pagination, authentication, or other behavioral details. There is no contradiction with the annotations.

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

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

The description is a single, front-loaded sentence with no filler words. Every word contributes meaning, and it is appropriately sized for a zero-parameter read operation.

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

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

For a simple read-only tool with no parameters, an output schema, and comprehensive annotations, the description is sufficiently complete. An agent can correctly infer the tool's purpose and invoke it without missing critical context.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics to explain. The description appropriately does not attempt to document parameters that do not exist, matching the baseline for a no-parameter tool.

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 ('saved Vaanzari picks'), making the tool's purpose immediately clear. It is distinguishable from siblings like get_cart or get_order by naming 'picks,' though it does not explicitly call out any 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 phrase 'saved picks' implies the tool is for reading previously saved picks, so an agent can infer when to use it. However, there is no explicit guidance about when not to use it or which alternative tool to choose, such as get_cart or save_pick.

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, so the safety profile is fully covered. The description adds some context about what is read (balance and recent transactions) but does not go beyond the annotations with additional behavioral detail.

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. It front-loads the action 'Read' and immediately specifies what data is returned.

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 zero parameters, an output schema present, and annotations covering safety and idempotency, the description fully equips an agent to select and invoke this tool correctly. Nothing critical is missing.

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

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

The tool has no parameters, so the description does not need to elaborate on parameter meanings. The schema is trivially complete, and the baseline for zero-parameter tools 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 uses a specific verb ('Read') and names the exact resource ('customer reward balance and recent point transactions'). It clearly distinguishes this tool from the many sibling get_* tools because no other sibling targets rewards.

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 context is clear: this tool is for reading reward data. It does not explicitly state when to use it versus alternatives, but there is no competing rewards-related sibling, so the intended usage is easy to infer.

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 readOnly, idempotent, and non-destructive behavior; the description adds the important visibility constraint and the accepted identifier types. It does not describe not-found behavior or auth requirements, but those are less critical given the annotations and output schema.

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

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

One tightly scoped sentence carries the action, the resource, the visibility rule, and the accepted identifier types. There is no redundant boilerplate.

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

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

For a simple single-parameter read tool, the description covers the essential selection criterion, and the output schema covers return values. An agent has enough information to decide and invoke correctly.

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

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

Schema coverage is 0%, but the description compensates by explaining that the single 'id' parameter can be a public catalogue ID or canonical locator. This adds real semantic meaning beyond the schema's pattern and length constraints, though it does not elaborate on the canonical locator format.

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

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

Names a specific verb and resource ('Get one visible Vaanzari saree') and the lookup key ('by public catalogue ID or canonical locator'). It is clearly distinct from search_sarees/list_artisans because it targets one item by identifier.

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 states the precise condition for using this tool: when you have a public catalogue ID or canonical locator and need one visible saree. It does not explicitly name alternative tools for search/listing, but the condition is clear enough without 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 read-only, idempotent, non-destructive behavior. The description adds that the response includes associated messages and that access is limited to authorized tickets, which is useful but modest given the existing annotation coverage.

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

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

A single sentence that front-loads the verb and resource with no filler. It is appropriately sized for a simple read operation.

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

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

For a one-parameter read tool with rich annotations and an output schema, the description covers the essential scope: a single authorized ticket plus its messages. Nothing an agent needs to select or invoke it correctly is missing.

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

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

Schema description coverage is 0%, so the description needed to compensate for the ticket_id parameter, but it never mentions its format, source, or constraints. The schema provides pattern and length rules, but the description adds no semantic value for parameter handling.

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

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

States a specific action ('Get') on a specific resource ('one authorized customer support ticket') and notes it includes messages, clearly differentiating from list/create/close/reply support ticket tools. The singular 'one' signals it is not list_support_tickets.

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

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

The description implies usage when a single ticket with messages is needed, but it does not explicitly say to use list_support_tickets for multiple tickets or to avoid this tool in other cases. No when-not or alternative routing guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful scoping ('public', 'visible catalogue') but does not disclose additional behavioral details such as pagination, ordering, or filtering 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?

A single, front-loaded sentence contains all essential information: the action, the resource, and the scope. 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?

For a zero-parameter, read-only listing operation with an output schema and comprehensive annotations, the description is sufficient. Nothing required to invoke the tool 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, so the baseline of 4 applies. The description does not need to explain parameter semantics because there are none.

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 ('List'), resource ('public artisan profiles'), and scope ('connected to the visible Vaanzari catalogue'). This clearly distinguishes it from singular tools like get_artisan and from unrelated listing tools like list_orders.

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

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

Usage context is implied by the word 'List' and by the public-profile scope, but there is no explicit guidance about when to choose this over get_artisan or search_sarees. No alternatives or exclusion criteria are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the 'authorized' scoping qualifier, which is useful but minimal. It does not describe pagination, ordering, or filtering behavior, though an output schema 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 a single, front-loaded sentence with no wasted words. It states the action, resource, and scope clearly and is appropriately sized for a zero-parameter read-only operation.

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

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

Given zero parameters, strong safety annotations, and the presence of an output schema, the description is nearly complete. It could add a note about whether the list is limited to the current customer or includes all authorized orders, but this is a minor gap rather than a blocking omission.

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 does not need to explain parameter behavior. The schema coverage is trivially complete at 100%, and the baseline for zero-parameter tools is 4. No additional parameter semantics are required.

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 ('List') and resource ('customer orders'), and adds a meaningful scope qualifier ('authorized'). It is easily understood and distinct from singular get_order, though it does not explicitly name a sibling or state how it differs from list_artisans/list_support_tickets.

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 usage guidance is provided. The description does not say when to prefer this over get_order or other list tools, nor does it mention any exclusions or prerequisites. Usage must be inferred entirely from tool name and 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, so the safety profile is established. The description adds only the 'authorized' scoping detail and does not mention pagination, filtering, ordering, or what the returned ticket collection contains.

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

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

The description is a single front-loaded sentence with no filler. It adds the meaningful 'authorized' qualifier over the title and wastes no words.

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

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

Given the low complexity, zero parameters, available output schema, and annotations covering safety, the description is nearly complete. The main gap is the lack of explicit guidance about when to prefer this list tool over the singular get_support_ticket.

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

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

The tool has zero parameters and schema coverage is 100%, so the baseline of 4 applies. There is no parameter information needed beyond what the empty schema already conveys.

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

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

The description clearly states the verb 'list' and resource 'customer support tickets', and the qualifier 'authorized' adds a scope not in the title. It is implicitly distinct from singular get_support_ticket and mutation siblings like create/close/reply_support_ticket, though it does not explicitly name those alternatives.

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

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

No explicit guidance is given for when to use this tool versus get_support_ticket, create_support_ticket, close_support_ticket, or other list tools. The intended usage must be inferred entirely from the tool name and sibling 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?

Annotations already disclose readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the mutation and safety profile is covered without description help. The description adds only a minor scoping note ('one' item) and does not address behavior for unknown item_ids, whether the entire line is removed, or side effects on cart totals. It does not contradict the annotations.

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

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

Five words forming one direct sentence with the verb front-loaded — there is zero padding or schema boilerplate. It is efficient rather than merely short, since it conveys verb, resource, and scope. It leans toward under-specification on usage guidance, but as a statement of the operation it 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?

Complexity is low (one required parameter, no nested objects), an output schema exists, and annotations cover the mutation profile, so much of the operational context is supplied externally. The real gaps are usage routing versus set_cart_quantity/remove_pick and the provenance of item_id, which an agent needs to call the tool correctly. Adequate for a simple tool, but not complete.

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

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

Schema description coverage is 0%, so the burden falls on the description to explain item_id, yet it only implies the parameter identifies a cart item. It does not specify where item_id comes from (e.g., a prior get_cart response) or clarify whether it is a cart line ID versus a product ID. Given the complete lack of schema descriptions, this compensation is minimal.

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 clear operation: 'Remove one customer cart item.' The verb 'Remove' and resource 'customer cart item' are specific and unambiguous, and the word 'one' scopes it to a single line item. It does not explicitly differentiate from siblings like remove_pick or set_cart_quantity, but the resource scope is clear enough to understand 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?

No when-to-use guidance, exclusions, or alternatives are provided. With sibling tools such as set_cart_quantity (which can set a quantity to zero) and remove_pick, an agent receives no help choosing among them. The single sentence only restates the operation without routing 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?

The description adds no behavioral detail beyond what the annotations already convey. It does not mention whether the removal fails if the saree is absent, whether it affects saved picks or cart, or any side effects. Since readOnlyHint=false and destructiveHint=false are already present, the description's single sentence simply restates the mutation without enriching the agent's understanding.

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. It front-loads the verb and object, making the core behavior instantly apparent.

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

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

The tool is simple: one required parameter, no nested objects, and an output schema exists, so return-value explanation is unnecessary. But the description lacks usage context, alternative differentiation, and behavior on missing IDs, which are relevant for a mutation tool even with annotations 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 partially compensates by linking the single action to 'one saree', which reasonably maps to the saree_id parameter. However, it does not explicitly explain that saree_id identifies which saree to remove or mention any constraints beyond the schema's own pattern and length rules.

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 ('Remove') and a clear resource ('one saree from customer picks'), making the tool's purpose immediately understandable. It differentiates from siblings like remove_from_cart by referring to 'picks' rather than 'cart', though it does not explicitly name the distinction.

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 given about when to use this tool versus alternatives such as remove_from_cart or save_pick. The description merely states the action, leaving the agent to infer the appropriate context from the tool name and sibling list.

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

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

Annotations already establish a non-read-only, non-idempotent write profile, so the description adds the useful behavioral trait of depending on a signed-in browser session with approval. But the clause is ambiguous about whether approval must already exist or is triggered by this call, and no failure behavior or side effects are described.

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 10-word sentence with the core action front-loaded and the conditional requirement appended. No filler, no repetition of schema or annotation data, and 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?

The output schema covers return values, and ticket_id and message are largely self-explanatory. However, the meaning of confirmation_id, the operational semantics of 'signed-in browser approval' (including behavior when approval is absent), and duplicate-reply or idempotency concerns are left unaddressed, making this only partially complete for a write action.

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

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

Schema description coverage is 0%, and the description names none of the three parameters. ticket_id and message are self-evident from names and schema constraints, but confirmation_id — an optional field with an unclear purpose — is explained nowhere, leaving a genuine gap the description was positioned to fill.

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 ('Reply to a customer support ticket'), clearly stating the core action and distinguishing it from sibling tools like create_support_ticket and close_support_ticket. The trailing 'after signed-in browser approval' clause slightly muddies the purpose statement, but the central action remains 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 phrase 'after signed-in browser approval' implies a precondition for use, giving the agent some sense of when the tool is viable. However, there is no explicit when-to-use guidance, no mention of alternatives such as close_support_ticket or create_support_ticket, and no statement about when to prefer this over other support-ticket actions.

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 show this is not read-only and not idempotent, but the description does not disclose material behavior such as whether resuming will charge/finalize the payment, what state changes occur, or what happens if called twice. The 'after signed-in browser approval' detail adds some context, but significant side-effect information is missing for a payment-affecting operation.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the action and resource, then adds the necessary precondition. Every word contributes to the meaning.

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

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

An output schema exists, so return values need not be explained, but the description still omits essential invocation context: what confirmation_id is, how to obtain it, and how this tool differs from retry_payment. For a payment-related mutation, this is not enough for confident correct use.

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

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

Schema description coverage is 0%, and the description must compensate for the undocumented parameters. It hints at 'attempt' matching attempt_id and 'browser approval' possibly relating to confirmation_id, but it never explicitly explains either parameter or their roles. This leaves the agent to guess.

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 ('Resume') and clearly identifies the resource ('unpaid hosted payment attempt') plus a precondition ('after signed-in browser approval'). It is clear and not a tautology, though it does not explicitly name or distinguish itself from the sibling retry_payment.

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

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

The phrase 'after signed-in browser approval' gives some contextual guidance about when the tool applies, but the description does not provide when-not-to-use guidance or direct the agent to an alternative such as retry_payment. Given those siblings, the selection guidance is only implied.

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

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

Annotations already establish readOnly=false and idempotentHint=false, so the agent knows this mutates state and is not safe to repeat. The description adds a state precondition ('unpaid', 'after signed-in browser approval') that is genuinely useful. However, it does not disclose what happens on success (a charge is triggered) or that a non-idempotent payment retry has financial consequences if called repeatedly. No contradiction with annotations, but the behavioral disclosure is shallow for a money-moving operation.

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

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

A single ten-word sentence with the verb and resource front-loaded and the precondition at the end. Every word earns its place; there is no repetition of the name or title and no filler.

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

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

The output schema covers return values, but this is a payment-affecting, non-idempotent operation with 0% parameter coverage and no sibling routing. An agent lacks the information to know where confirmation_id comes from, when to call this versus resume_payment, and what side effects (a charge) will occur. For a high-stakes financial call, the definition is under-specified.

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

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

Schema description coverage is 0%, so the description must carry the parameter explanation burden, and it does not. 'unpaid hosted payment attempt' hints at attempt_id and 'signed-in browser approval' hints at confirmation_id, but neither parameter is named, and the source/format of confirmation_id (e.g., where the agent obtains it after approval) is unexplained. This is insufficient for an agent to confidently populate a required and an optional input.

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 ('Retry') with a clear resource ('unpaid hosted payment attempt') and adds a precondition ('after signed-in browser approval'). This is clearly not a tautology and is more specific than 'Retry Payment'. However, it does not explicitly differentiate itself from its nearest sibling, resume_payment, so it stops short of full sibling distinction.

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 when-to-use or when-not-to-use guidance, and no alternatives are named. With 28 siblings including resume_payment, cancel_payment_attempt, and start_checkout, the agent gets no routing help. The phrase 'after signed-in browser approval' implies a context, but it never tells the agent which sibling to choose instead under other 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 already convey idempotence and non-destructiveness, lowering the burden on the description. The description adds a 'visible saree' precondition, but does not explain what happens if the saree is not visible or whether saving an existing pick is treated as an update.

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

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

The description is a single, front-loaded sentence with no filler or repeated information. It would benefit from defining 'visible,' but as a concise statement it is efficient.

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

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

Given the low complexity, one parameter, annotations, and an output schema, the description is reasonably complete. It still leaves the 'visible' rule unexplained and offers no direction about related pick-management tools, creating minor gaps for an agent.

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

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

With 0% schema description coverage, the description must compensate, and it does add minimal meaning by specifying 'one visible saree.' Still, it does not clarify where the saree_id should come from or elaborate on the 'visible' eligibility condition beyond the schema's generic ID pattern.

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 ('Save'), a resource ('saree'), and a destination ('customer picks'), so an agent can understand the basic operation. However, it does not explicitly distinguish this tool from siblings like add_to_cart or remove_pick, and 'visible' is ambiguous.

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 given about when to use save_pick versus alternatives such as add_to_cart, get_picks, or remove_pick. The intended use is only implied by the phrase 'customer picks,' with no exclusions or 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?

Annotations already establish read-only and idempotent behavior. The description adds meaningful context beyond annotations by stating that only visible sarees are searchable and that verified catalogue fields are used, plus noting that missing attributes remain unset. This gives agents useful expectations about result coverage and field completeness.

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 filler. It earns its place by stating scope and a key behavioral caveat, though 'Missing attributes remain unset' is somewhat cryptic and could be clearer.

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?

Although the output schema may document return values, the description leaves significant gaps: it does not explain how filters interact, what 'verified catalogue fields' means for parameter values, or how pagination works. An agent could call the tool but lacks essential context for precise query construction.

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 schema description coverage at 0% and seven parameters, the description bears the burden of explaining how to use q, fabric, region, occasion, technique, page, and limit. It does none of that; 'verified catalogue fields' is too vague to clarify valid values or filtering 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 action ('Search'), the resource ('visible Vaanzari sarees'), and the intended scope ('using verified catalogue fields'). It distinguishes this tool from siblings like get_saree by indicating it searches across a filtered, visible catalogue rather than retrieving a single known item.

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

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

The description implies use for searching the visible catalogue but never explicitly states when to prefer this over a sibling such as get_saree or list_artisans. There is no exclusion guidance or alternative routing, leaving the usage context only partially defined.

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=false, idempotentHint=true, and destructiveHint=false, and the description is consistent with them (no contradiction). The phrase 'Set quantity' usefully implies overwriting the existing quantity rather than incrementing it. However, it does not disclose prerequisites, ownership/authentication requirements, or error behavior when the item is absent.

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 seven-word sentence with the verb front-loaded and no filler words. It is efficient and scannable, though the brevity borders on under-specification given the 0% schema parameter coverage.

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 setter with an output schema and safety annotations, the description is minimally adequate. The main gaps are the absence of usage context relative to the closely related cart siblings and the ambiguous meaning of item_id. Since an output schema exists, the lack of return-value documentation is not penalized.

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. It loosely maps 'quantity' and 'cart item' to the two parameters, but it does not clarify whether item_id refers to a product ID or a cart line-item ID, nor does it explain that quantity is an absolute value (1–20) replacing the current quantity. This leaves an agent guessing.

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 ('Set') and a precise resource ('quantity for one customer cart item'). It clearly scopes the action to a single cart item, which implicitly distinguishes it from siblings like add_to_cart and remove_from_cart. However, it does not explicitly name or contrast those alternatives, so differentiation relies on inference.

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 add_to_cart, remove_from_cart, or get_cart. There are no stated prerequisites (e.g., the item must already exist in the cart) and no exclusion conditions. An agent must infer the use case entirely from the title and sibling names.

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

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

Annotations already indicate idempotentHint=true and readOnlyHint=false. The description adds meaningful behavioral context: the checkout is hosted, requires prior browser approval, and does not capture payment. This goes beyond what annotations alone provide and contradicts nothing.

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

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

Two short sentences, front-loaded with the core action and followed by a key caveat. Every word earns its place; no filler or repetitive schema content.

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

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

For a tool with 8 parameters, 0% schema descriptions, and 2 required fields, this description is incomplete. An agent still cannot determine how to fill idempotency_key, what billing_address or shipping_address mean, how points_to_redeem behaves, or what the browser-approval flow requires. An output schema exists but does not compensate for missing input semantics.

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 carry parameter meaning, but it only restates the provider enum (Cashfree or PhonePe) and omits explanation for the required idempotency_key, addresses, coupon, points, and confirmation_id. It adds no meaning beyond what the enum already conveys, and it ignores the 'online' payment_method option.

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

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

States a specific verb and resource ('Create a hosted checkout'), names the supported providers (Cashfree or PhonePe), and adds a prerequisite (signed-in browser approval). The explicit note that no payment is captured clearly separates it from payment-related siblings like retry_payment and resume_payment.

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

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

Gives some context ('after signed-in browser approval') and a boundary ('No payment is captured by this tool'), which implies a later payment step. However, it does not explicitly name alternatives or state when not to use this tool versus siblings like resume_payment, retry_payment, or get_checkout_summary.

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

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

The description discloses that this is a write operation to specific profile fields and adds a key behavioral detail not present in annotations: a signed-in browser approval is required. Annotations already provide idempotentHint=true and destructiveHint=false, and the description does not contradict them.

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 conveys the action, object, and precondition with no filler. Every word adds meaningful guidance, making it an efficiently structured definition.

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

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

Given a simple 4-parameter update with an output schema present, the description covers the essential purpose, the main parameters, and the approval precondition needed to invoke the tool correctly. The only notable gap is the unexplained confirmation_id parameter, which is optional and therefore does not block 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?

With schema_description_coverage at 0%, the description compensates partially by explaining the semantics of three parameters: name, phone, and delivery address. However, the optional confirmation_id parameter is not mentioned at all, leaving the agent without insight into its role as an approval token or idempotency identifier.

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 'Update customer name, phone, and delivery address,' naming a specific verb, resource, and target fields. The title 'Update Profile' reinforces the resource, and since no sibling tool handles profile updates, the purpose is unambiguous despite not naming a differentiating 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 phrase 'after signed-in browser approval' states a concrete precondition for invoking the tool, giving the agent a clear gate for when it is appropriate. It does not describe alternatives or when-not-to-use scenarios, but the lack of any competing profile-update sibling makes this context sufficient.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate non-mutation. It adds useful context about the authorized cart, but it does not disclose behaviors such as how invalid/expired coupons are handled or what the validation result contains.

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

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

A single, front-loaded sentence with no filler. Every word contributes meaning, and the description is appropriately sized for a simple single-parameter tool.

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 low-complexity, read-only tool with an output schema and only one parameter, the description plus annotations cover most operational needs. The main gap is the lack of explicit usage guidance, but the authorized-cart context and input schema make it usable.

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 explicitly explain the 'code' parameter beyond inferring it is the coupon code from the tool name. The parameter name and length constraints are minimally self-explanatory, but the description adds no real semantic 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 ('validate') and a clear resource ('coupon') with the scope 'against the authorized customer cart.' It distinguishes validation from other cart operations, though it does not explicitly differentiate from a coupon-specific sibling because none exists.

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 'against the authorized customer cart' implies the tool is used in a cart/checkout context, but there is no explicit statement of when to use it or when to prefer an alternative. Since no sibling coupon tool exists, the ambiguity is low.

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