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?

Adds real behavioral context beyond the annotations: only eligible orders, cancellation notices are dispatched (a downstream side effect), and signed-in browser approval is required. This complements destructiveHint/idempotentHint without contradicting 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?

A single front-loaded sentence with no filler, leading with the core action. It is efficient, though it could afford one more clause to clarify eligibility and confirmation_id.

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 removes the need to describe return values, and annotations cover the safety profile. Still, the description leaves 'eligible' undefined and says nothing about the three input parameters, which is a gap for a destructive, non-idempotent operation.

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

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

Schema description coverage is 0% across three parameters, so the description carries the full burden, yet it explains none of them. 'signed-in browser approval' vaguely gestures at confirmation_id but never connects it, and reason/order_id are entirely undefined.

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 (cancel) and resource (customer order), plus the side effect of sending cancellation notices. It is distinguishable from siblings like cancel_payment_attempt, though it doesn't explicitly name an 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?

Implies usage conditions via 'eligible' and 'signed-in browser approval', giving some context for when this applies. However, it never defines eligibility, states prerequisites precisely, or points to alternative tools for ineligible cases.

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, it discloses important side effects: persisting provider state, possibly restoring reservations, and finalizing an already-paid order, while explicitly stating it does not capture payment. The destructiveHint=true annotation is consistent with this, and the description meaningfully adds provider-auth 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 short and front-loaded, with no filler. Its density is high because it packs provider conditions, side effects, and persistence into two sentences, but it remains readable.

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

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

The output schema exists, so return values need not be described, and annotations cover safety traits. Still, with 0% schema description coverage, the description leaves a key parameter (confirmation_id) unexplained and only weakly identifies attempt_id.

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 two parameters. It does not clarify attempt_id, and it does not mention confirmation_id at all, leaving required invocation semantics largely undocumented.

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 concrete actions and resources: cancel an unpaid Cashfree session, check Razorpay/PhonePe/Paytm status, and persist provider state. It is specific enough to distinguish this from a simple status-check tool, though the mixed cancel/check behavior is somewhat unusual for a tool named cancel_payment_attempt.

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 provider-specific conditions (unpaid Cashfree session vs. after signed-in browser approval) and clarifies that it does not capture payment. However, it does not explicitly contrast this with siblings like get_payment_status, retry_payment, or resume_payment, leaving some when-to-use guidance 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 declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuine non-obvious context: the action notifies external support staff with a closing remark and requires signed-in browser approval, which is exactly the kind of side effect an agent must know before invoking.

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 that packs purpose, side effect, and precondition with zero 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?

An output schema exists so return values need no explanation, and the approval precondition is stated. However, with a mutation tool whose params are fully undocumented, failing to explain confirmation_id and what 'closing remark' contains leaves an agent unsure how to complete the call.

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 explains neither parameter. ticket_id is only loosely implied, and confirmation_id — presumably tied to the browser approval flow — is never mentioned, leaving the required second parameter opaque.

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 (close a support ticket) plus the side effect of sending a closing remark, which separates it from get_support_ticket and reply_support_ticket. It does not name a sibling explicitly, so it stops short of a 5.

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

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

Usage is only implied: closing is the terminal action on a ticket. The one real guideline is the prerequisite 'after signed-in browser approval', but there is no explicit when-to-use versus reply_support_ticket or when not to close.

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 and idempotentHint=false, and 'cannot be unsent' reinforces that irreversibility rather than contradicting it. The added value is the disclosure of a signed-in browser approval step, an auth/precondition detail the annotations do not convey.

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

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

Two short sentences, front-loaded with the action and immediately followed by the irreversible consequence. 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?

An output schema exists so return values need not be explained, and the mutation/irreversibility profile is covered. However, with four undocumented parameters and no guidance on when order_id or confirmation_id should be supplied, the definition is not complete enough for confident 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% across 4 parameters, so the description must carry the burden and it does not. It only vaguely implies a 'submitted message' and says nothing about subject, order_id, or confirmation_id, leaving three of four params semantically opaque.

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: sending a new customer support request to Vaanzari staff. The word 'new' implicitly distinguishes it from reply_support_ticket and close_support_ticket, but no sibling is named explicitly, so it falls short of a 5.

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

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

Gives one precondition ('after signed-in browser approval') which hints at when it is callable, but offers no exclusions or guidance on choosing between this and reply_support_ticket or close_support_ticket.

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 declare readOnlyHint, idempotentHint true and destructiveHint false, so safety is covered. The description usefully reinforces that no order is placed, but says nothing about whether revalidation has hidden side effects (inventory hold, cart lock) or any auth/rate-limit requirements, so it adds modest value over 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?

One sentence, zero filler, with the computed fields listed first and the critical non-mutating constraint front-loaded at the end of the same 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?

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. The description is complete enough to call the tool, with the only residual gap being optional-parameter behavior for the four nullable inputs.

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% across 4 params, so the description must compensate; it does so only coarsely, mapping 'discounts' to coupon_code, 'points' to points_to_redeem, and 'addresses' to the two address strings. It never states that all inputs are optional or what happens when one is omitted, leaving real format/semantics 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 gives a specific verb ('revalidate') plus an enumerated resource set (cart, discounts, points, addresses, checkout total), which tells the agent exactly what is recomputed. The trailing clause 'without placing an order' separates it from the mutating sibling start_checkout, so no schema opening is needed to disambiguate.

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 only implied via 'without placing an order', which hints at a pre-purchase preview scenario, but no sibling (start_checkout, validate_coupon, get_cart) is named as an alternative and no prerequisites or exclusions are stated. An agent must infer the correct moment to call 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 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?

Goes well beyond the annotations by disclosing concrete side effects: it persists state, may finalize an already-paid order, and may send confirmation notices. This is consistent with readOnlyHint=false and destructiveHint=true while adding the specific consequences an agent needs before invoking, plus the explicit non-goal of initiating or capturing payment.

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 tightly written sentences: the primary action is front-loaded, followed by side effects and the boundary clause. No filler, and every clause adds operational 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 no explanation, and annotations already cover safety hints. The description covers side effects and boundaries well; the only meaningful gap is the absence of any guidance on the attempt_id input, which is the sole required parameter.

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 burden. It contextualizes attempt_id as a 'customer payment attempt from Razorpay, Cashfree, PhonePe, or Paytm,' which hints at the identifier's origin, but never explains where to obtain it, its format, or its lifecycle, leaving the single required parameter only partially 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?

States a specific verb (refresh) and resource (customer payment attempt), names the four gateways involved, and clarifies the persistence of server-verified state. The clause 'does not initiate or capture payment' further separates it from resume_payment/retry_payment, so an agent can distinguish it from siblings without opening schemas.

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 exclusion ('does not initiate or capture payment') gives a clear when-not, and the refresh/persist framing implies when to use it. However, it never names the alternatives (resume_payment, retry_payment, get_order) or states an explicit condition that selects this tool over them, so routing is partly 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 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, non-destructive, and closed-world behavior. The description adds useful behavioral context beyond annotations: only visible sarees are returned, a canonical storefront URL is included, and that URL should be presented as a clickable product link. It does not cover error behavior for invalid or non-visible IDs.

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 tightly written sentences with no waste. The core retrieval behavior is front-loaded, and the output/presentation guidance follows logically.

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 enumerated. Annotations cover safety traits, and the description adds visibility scope and URL presentation guidance. Minor gaps remain around failure behavior for invalid or hidden IDs.

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 for the single 'id' parameter. It usefully explains that the id may be a public catalogue ID or canonical locator, adding meaning beyond the schema's type and pattern constraints.

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 gives a specific verb ('Get'), resource ('Vaanzari saree'), and scope ('one visible', by public catalogue ID or canonical locator). It implicitly distinguishes from search_sarees through the singular retrieval and ID/locator lookup, but does not name the sibling alternative explicitly.

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

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

The description indicates the retrieval context (by public catalogue ID or canonical locator) and provides presentation guidance for the returned URL. However, it does not explicitly say when to use this tool versus alternatives such as search_sarees, leaving selection guidance 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 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 declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond those hints: it never says whether the whole line item is deleted or a quantity is decremented, what happens if the item is absent, or whether the cart must be non-empty.

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 short sentence with the action front-loaded and zero filler. It is efficient, though its brevity is the cause of the gaps scored elsewhere rather than a virtue in itself.

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, and the annotations cover the safety profile for this simple single-parameter tool. Still missing is the behavior that resolves the ambiguity with set_cart_quantity and the outcome when the item is not in the cart.

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 burden for item_id. It only implicitly conveys that the parameter identifies a cart item, adding no format, source, or lookup guidance beyond the schema's pattern and length constraints.

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 (remove) and resource (a customer cart item), which is enough to distinguish it from add_to_cart and get_cart. It does not, however, differentiate itself from the near-sibling set_cart_quantity, which could plausibly implement the same outcome by setting quantity to zero.

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 guidance, no prerequisites (e.g. cart must be active), and no mention of alternatives such as set_cart_quantity or remove_pick. The agent must infer context entirely 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 declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: it does not say whether the removal is permanent, whether it requires auth, or how it interacts with cart/pick state.

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 wasted words. It is efficient, though its brevity is close to under-specification rather than true crispness.

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 handles return values and the annotations handle safety semantics, so the remaining burden is light for a one-parameter tool. Still, the description omits what removal actually affects (e.g. does it delete all saved picks of that saree, is it reversible), leaving a small 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?

Schema description coverage is 0%, so the parameter has no schema-level documentation, and the description only implies the parameter is the saree to remove ('one saree'). It does not explain the ID format or constraints already encoded in the pattern/maxLength, so it adds only marginal 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?

States a specific verb (remove) and resource (one saree from customer picks), which is enough to distinguish it from remove_from_cart at the resource level. It does not name or contrast with the closer siblings get_picks/save_pick, so it falls short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of the sibling tools (save_pick, get_picks, remove_from_cart) that an agent must choose between. The agent is left to infer everything from the name.

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

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

Annotations already cover destructive/non-idempotent/open-world, and the description adds genuinely new behavioral facts: the message 'cannot be unsent' (irreversibility) and that a closed ticket may be reopened as a side effect, plus the browser-approval auth gate. It does not mention rate limits or confirmation flows, keeping it short of 5.

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, front-loaded with the core action, with zero filler. The irreversibility warning is placed immediately after the action so it is read before invocation.

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, and the safety/auth picture is reasonably covered. The unexplained confirmation_id and the conditional reopen behavior's exact trigger leave a meaningful gap 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% for 3 parameters, so the description must carry the load. It vaguely implies a message is submitted but never addresses ticket_id or the unexplained confirmation_id, its format, or whether it is required for the approval flow.

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+resource ('Send a reply to Vaanzari support staff') and adds scope detail (reopens a closed ticket if needed), which separates it from close_support_ticket and create_support_ticket. It does not name a sibling explicitly, so it stops short of a 5.

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

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

Gives a prerequisite ('after signed-in browser approval') and implies when reopening occurs, but names no alternative tool and states no when-not-to-use conditions. Usage is implied rather than fully 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?

Annotations declare this is a non-readonly, non-idempotent, destructive, open-world operation. The description adds real side-effect context beyond that: it may finalize an already-paid order and send confirmation notices, and explicitly does not capture payment. These are meaningful traits and are consistent with destructiveHint=true, not contradictory.

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

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

Two dense sentences with no filler, front-loading the primary action and following with side effects and scope limits. The phrasing is terse and jargon-heavy but every clause carries 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?

An output schema exists, so return values need not be described, and the annotations cover the safety profile. What remains missing is any parameter guidance, which for a 2-param, 0%-coverage schema is a real gap for an agent deciding whether and how to call it.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining attempt_id and confirmation_id, yet it names neither parameter. It gives no indication of what attempt_id identifies or when the optional confirmation_id should be supplied, so the low-coverage gap is left unfilled.

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: synchronizing provider state and returning an existing unpaid hosted checkout after browser approval. It is not a tautology of the name, but it never distinguishes itself from the close sibling retry_payment or get_payment_status, so an agent must infer which of the three payment tools applies.

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 usage condition (an operator/user has returned from a hosted checkout flow), which is useful context. However, it names no alternatives and gives no when-not guidance against retry_payment or start_checkout, leaving the routing decision 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 real context beyond the annotations: it discloses the precondition (signed-in browser approval), the side effects (reserving stock/rewards), and an explicit non-behavior ('Does not capture payment'), which usefully qualifies the destructiveHint=true mutation. It still doesn't address reversibility or idempotency of the newly created 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?

A single dense sentence leads with the action and follows with the precondition, side effects, and non-behavior. The gateway-name list is slightly padded but the sentence is front-loaded and free of 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?

An output schema exists, so return values need not be described, and the annotations cover the safety profile. The remaining gap is the total absence of parameter guidance for a non-idempotent, destructive mutation, which the description never compensates for.

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 neither parameter is named or explained. 'Attempt' and 'signed-in browser approval' only obliquely hint at attempt_id and confirmation_id, leaving the agent to guess which identifier to supply and where to obtain it.

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?

Concrete verb ('Create a replacement hosted ... checkout') plus a precisely scoped resource (a failed or terminated payment attempt) and the gateway options. It does not differentiate itself from the closely related sibling resume_payment, so it stops short of a 5.

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

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

States the selecting condition clearly: use it for a failed or terminated attempt, and only after signed-in browser approval. It gives no explicit when-not guidance or pointer to resume_payment / cancel_payment_attempt as alternatives, so it lacks 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 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 declare this as a read-only, idempotent, non-destructive, closed-world operation, so safety is covered. The description adds genuine behavioral detail: each result carries a canonical storefront url, and missing attributes remain unset rather than erroring. It does not cover pagination behavior or empty-result handling.

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

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

Three short, front-loaded sentences with no filler; the core purpose leads and the result-handling note follows. Nothing is wasted, though the sentences are terse enough that a little more filter detail could be added 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 not be re-explained, but with 7 undocumented parameters at 0% coverage the description leaves core filtering behavior unspecified. For a multi-faceted catalogue search, the absence of any filter or pagination guidance is a real 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?

Schema description coverage is 0% and the description supplies no detail about any of the 7 parameters. Terms like 'verified catalogue fields' and 'visible' hint at filtering but never map to q, fabric, region, occasion, technique, page, or limit, leaving the agent to guess filter 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?

States a specific verb (Search) and resource (visible Vaanzari sarees) scoped to verified catalogue fields, which distinguishes it from the singular get_saree sibling. It is clear what the tool returns at a high level, though it does not explicitly name an alternative tool.

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 search framing, and the description adds a presentation instruction (include the canonical url as a clickable product link). However there is no explicit guidance on when to prefer this over get_saree or how to combine the fabric/region/occasion/technique filters.

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

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

Annotations already declare the safety profile (destructiveHint=true, idempotentHint=true, readOnlyHint=false), so the mutation/idempotency facts are covered. The description adds only the 'one customer cart item' scoping detail, which is mildly useful, but says nothing about what a destructive set entails or how out-of-range behavior is handled.

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

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

A single front-loaded sentence with zero filler. It is efficient, though the terseness is what leaves the other dimensions under-covered.

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 for a destructive, idempotent mutation with 0% parameter documentation, the description omits error conditions, cart-state prerequisites, and per-item call semantics. Too little for an agent to call it confidently.

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% for two parameters, so the description must compensate and largely does not: it names 'quantity' but gives no bounds, and never explains that item_id must reference an existing cart item. The 1-20 range and id pattern live only 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?

States a specific verb (set) and resource (quantity for one customer cart item), which an agent can distinguish from add_to_cart and remove_from_cart. It is clear but never names or contrasts those siblings explicitly.

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

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

No guidance on when to use this versus add_to_cart/remove_from_cart, no prerequisites (e.g., must the item already be in the cart), and no exclusions. The agent must infer all routing from the name alone.

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 declare destructiveHint=true and idempotentHint=true, but the description adds what is actually destroyed (cart cleared, stock/rewards reserved), the payment-synchronization behavior, the possibility of finalizing an already-paid order, and the crucial non-obvious fact that no payment is captured here. This is exactly the beyond-annotations context the dimension rewards.

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?

Six tight sentences, front-loaded with purpose, then prerequisite sequencing, then per-provider constraints, then side-effect warnings. No filler, and each sentence carries distinct 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?

Return values are covered by the output schema and the annotation profile is reinforced, so the description is nearly complete for a tool of this complexity. The remaining gap is the undocumented required/optional parameters (idempotency_key, confirmation_id) and how payment_scope relates to payment_method, given 11 params at 0% schema coverage.

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

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

With 0% schema description coverage and 11 parameters, the description must carry the parameter burden. It meaningfully explains expected_total/expected_currency (must match the get_checkout_summary approved total) and ties addresses/discounts/points to that prior call, but leaves idempotency_key, confirmation_id, payment_mode, and payment_scope, including how payment_method='online' differs from the named providers, undefined.

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 concrete verb (Create) and resource (hosted checkout), names the supported providers, and lists the transactional side effects (reserving stock/rewards, clearing the cart) that distinguish it from siblings like get_checkout_summary or resume_payment. An agent can separate it from every neighboring tool without opening a schema.

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 explicit sequencing ('First call get_checkout_summary... submit its approved total/currency'), plus branch constraints (international delivery requires Razorpay in delivery currency; Paytm is domestic INR only). It covers preconditions and conditional eligibility, not just a vague 'use this to pay'.

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 destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered elsewhere. The description adds the browser-approval gate, a meaningful behavioral/auth condition not present in the structured data, but it omits what state is overwritten and whether partial updates are possible.

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; the precondition is tacked on at the end but the sentence remains compact and readable.

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, non-readOnly mutation with four undocumented parameters and 0% schema coverage, the description should explain confirmation_id and the overwrite semantics. An output schema exists so return values need not be described, but the approval mechanics and the fourth parameter are left unexplained.

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 burden. It names three of four parameters but says nothing about the optional confirmation_id, which is clearly tied to the approval flow, and gives no format/length guidance for any field.

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 (Update) plus the resource (customer profile) and enumerates the mutated fields (name, phone, delivery address). No sibling tool touches profiles, so there is nothing to disambiguate against, keeping it just short of a 5.

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

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

The clause 'after signed-in browser approval' communicates a precondition for use, which is genuine usage context. However, it does not say what to do if approval is absent, how approval is obtained, or how this relates to other write operations, so guidance remains implied rather than explicit.

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

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

Annotations already 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.