Custom Blinds Shop

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It clearly states the operation is permanent and irreversible, and explicitly disclaims any effect on existing checkouts or orders. This is strong behavioral disclosure for a destructive tool.

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

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

Three sentences, front-loaded with the core action, then usage context, then side effects. No redundant phrasing or filler. Every sentence earns its place.

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

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

For a one-parameter delete tool with no output schema, the description covers purpose, usage, and consequences. It lacks only minor details like success/error return values or authorization requirements, but these are not critical for understanding the tool's function.

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

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

Schema description coverage is 0%, so the description must compensate. It merely repeats the parameter name ('by cart_id') without adding constraints, source, or format guidance. It does not explain where cart_id comes from (e.g., returned by create_cart) or any validation 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 begins with 'Permanently delete a cart by cart_id', which is a specific verb+resource action. It clearly distinguishes cancel_cart from sibling tools like get_cart, update_cart, and cancel_checkout by focusing on deletion of the cart itself.

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 provides explicit guidance: 'Use when the customer abandons the session or wants to start over.' It also clarifies a limitation ('Has no effect on any checkout or paid order already created') and suggests an alternative ('create a new cart to restart'), which helps the agent choose correctly.

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

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

With no annotations, the description carries the burden of disclosure. It reveals a key behavior: no effect on orders already confirmed by webhook. However, it doesn't mention whether the operation is reversible, requires permissions, or impacts the associated cart beyond the implication of restarting from scratch.

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

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

Three sentences: action, usage context, exclusion and restart instruction. No redundant phrases, information is front-loaded, and every sentence adds value.

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

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

For a simple tool with one parameter and no output schema, the description covers the action, timing, limitation, and next steps. It lacks explicit error handling or cart side effects, but the restart instruction implies the cart is no longer usable, which is sufficient.

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

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

Schema coverage is 0%, so the description must compensate. It does clarify that checkout_id refers to the checkout created by create_checkout, but it doesn't add format or type details beyond the schema's string type. For a single obvious parameter, this is adequate.

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 ('Abort an unpaid checkout') and the resource ('checkout_id'). It clearly distinguishes from siblings like cancel_cart (cart vs checkout) and complete_checkout (finalization vs abort).

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

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

It explicitly states when to use: 'if the customer changes their mind after create_checkout but before completing payment.' It also provides an exclusion (no effect on webhook-confirmed orders) and an alternative (create a new cart and checkout).

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?

With no annotations, the description carries full burden, and it delivers by disclosing the return payload ('in_stock boolean, expected_restock_date if out of stock, and up to 5 alternative in-stock colours ordered by similarity'). This goes beyond simple mutability and informs the agent of side effects (none implied) and output structure without being verbose.

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 with no filler. The first sentence states the action and return values; the second provides usage triggers. Both earn their place and the description is immediately scannable.

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

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

Given the low complexity (2 params) and no output schema, the description fully covers what the tool returns, when to use it, and its role in the workflow. No gaps remain for an agent to guess.

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%, and the description does not explicitly define product_id or colour_name. However, the parameter names are self-explanatory, and the description implies that 'colour' corresponds to colour_name and the action is per product. The baseline for low coverage is 3; the description adds minimal semantic value beyond the schema.

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

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

The description uses a specific verb ('Verify') and a specific resource ('whether a specific colour is available'), distinguishing this from sibling tools like get_product or configure_product. It clearly states the tool's role as a pre-check for colour availability before product configuration.

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

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

Explicit guidance is provided: 'Call this when a customer requests a named colour or when you want to prevent a configure_product failure due to an out-of-stock selection.' This also frames the tool as a prerequisite step, giving clear context for when to invoke it versus alternatives.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It reveals that the checkout is locked after calling, that payment confirmation is asynchronous via webhook, and that a payment_url is returned. This exceeds what basic annotations would provide and gives crucial operational 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 compact and information-dense, with every sentence providing essential details: phase, purpose, return value, async confirmation, and locking side-effect. The front-loaded structure ensures the agent quickly grasps the core function and key caveats.

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

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

For a two-parameter tool with no output schema and no annotations, the description is unusually complete. It covers purpose, side-effects, next steps, and alternatives, making it sufficient for an agent to use correctly without needing external documentation.

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?

Although the schema description coverage is only 50% (checkout_id lacks a description), the tool description enriches the meaning of both parameters. It clarifies that payment_method choices correspond to specific payment types, and the 'Phase 2' context implies checkout_id comes from create_checkout. This compensates reasonably for the schema gap, though explicit mention of checkout_id would be clearer.

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

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

The description clearly states the tool's function: it finalises a checkout and generates a payment link, with the specific options Yoco and Ozow. It distinguishes itself from sibling tools by positioning as 'Phase 2 of 2' and explicitly contrasting with cancel_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 description provides concrete guidance on when to use this tool vs alternatives. It mentions to use cancel_checkout if the customer changes their mind, and to poll get_order to confirm payment status, giving a clear workflow and exclusion criteria.

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?

With no annotations, the description carries the full transparency burden. It discloses key behaviors: validating colour existence/stock and pricing the blind, and it states the return format (configuration summary for create_cart). However, it does not explicitly mention whether the operation is non-mutating or stateless, though the phrase 'pass directly into create_cart' strongly implies it. Slightly more detail on side effects would earn a 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?

The description is exactly three sentences long, each serving a distinct purpose: defining the action, describing validation/pricing, and explaining the output/prequel. No filler, no repetition, and the key verb is front-loaded. Excellent structure.

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 and no output schema, the description provides essential context: it validates stock, prices, and returns a summary for create_cart. It also gives a usage precheck. Missing details like how quantity/province/finish affect pricing are covered by the schema, so the description is largely complete for an agent to invoke the tool correctly. A slight gap is the absence of any note about error behavior (e.g., what happens if validation fails), which could merit a 5.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by grouping core parameters as a 'full blind specification', clarifying the purpose of the configuration (to feed create_cart), and adding the stock-validation detail for the colour parameter. This integration goes beyond the schema's individual field descriptions.

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

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

The description opens with a specific action phrase 'Lock in a full blind specification' and enumerates the exact inputs: product, dimensions, colour, and mount type. It also clarifies the tool's role (validation and pricing) and distinguishes it from siblings like create_cart (which the output feeds) and check_colour_stock (which is a precheck). No 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 tool explicitly tells the user to call check_colour_stock first if availability is uncertain, and it states that the returned configuration summary should be passed directly into create_cart. This gives clear sequencing and an explicit alternative, removing guesswork about when to use this tool versus its 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?

With no annotations provided, the description carries the full burden. It discloses key behaviors: no auth needed, returns a cart_id with a 24-hour TTL, and optional seeding with items/customer. This adds significant context beyond a basic 'creates a cart'. It doesn't mention error cases or idempotency, but for this simple creation tool, it's fairly transparent.

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 three sentences, front-loaded with the primary action, followed by key details and next steps. Every sentence contributes value with no filler, making it exceptionally concise and well-structured.

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

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

For a simple tool with two optional parameters and no output schema, the description is complete. It explains the purpose, return value (cart_id), TTL, and next steps in the flow. No critical information is missing for an agent to select and invoke this tool correctly.

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

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

Schema coverage is 100% (items and customer both have descriptions). The description adds the concept of 'seed' and clarifies items are 'pre-configured blind items', but this largely restates what's in the schema. It provides minor additional semantics without deep detail, hence a baseline 3.

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

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

The description clearly states the tool's purpose: 'Start the open UCP purchase flow' and 'Creates a cart session and returns a cart_id'. It uses a specific verb and resource, distinguishing it from siblings like cancel_cart, update_cart, and get_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?

It explicitly provides a workflow: 'Next step: update_cart to add items, then create_checkout → complete_checkout'. This indicates exactly when to use this tool (at the start) and how it fits with related tools. It also notes 'no auth needed', setting clear expectations.

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?

With no annotations, the description discloses key behaviors: returns checkout_id, does not mint a payment link, and requires customer name/email/phone. It also frames the tool as a preliminary step, setting expectations for subsequent actions. Some side effects (e.g., cart impact) are not described, but the provided context is substantial.

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

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

The description is four sentences, each serving a purpose: purpose, conversion, requirements/return, and next steps. It is front-loaded with the primary action and phase, with no filler.

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

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

For a create operation with no output schema, the description covers workflow, return value, and required fields. It lacks details on error conditions and effects on cart, but given low-to-moderate complexity and schema availability, it is adequately complete.

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

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

The description clarifies that either cart_id or items must be supplied, and specifies required customer fields, complementing the schema. It does not detail the shape of items or payment_method default, but schema covers those. The description adds meaningful semantic context beyond the 50% schema coverage.

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

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

The description clearly states the tool's role as Phase 1 of a 2-phase purchase flow, converting a cart or inline items into a checkout. It distinguishes itself from sibling tools like complete_checkout and update_checkout, making the purpose unambiguous.

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

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

Explicitly says when to use: to create a checkout, and when not: payment link minting requires complete_checkout. It also points to update_checkout for correcting customer details, giving clear guidance on alternatives.

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

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

The description discloses that prices are re-verified server-side and agent-supplied prices are ignored, which is critical behavioral information. It also notes the auth requirement and that it returns a payment_url. Since there are no annotations, the description carries the full burden and does so effectively.

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

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

The description is two sentences, efficient and structured. It front-loads the legacy warning and directs users to the alternative before describing the tool itself, with no redundancy.

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

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

The description is complete for this tool's purpose: it explains why to use it, what it returns, and the key behavioral twist. The absence of an output schema is compensated by naming the return type. It fits well within the sibling ecosystem.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a crucial caveat about price fields being ignored, which directly impacts how the agent should populate those parameters. This elevates the usefulness beyond the schema, so a 4 is warranted.

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 create_order as a legacy, auth-required tool that creates an order and returns a payment URL. It distinguishes itself from the UCP flow by being a single-call alternative, making its purpose and scope explicit.

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

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

It explicitly states when to use this tool ('only if you hold a Bearer token and want a single-call path') and when to prefer the alternative (the UCP flow). This gives the agent clear decision criteria, including the credential requirement.

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?

With no annotations, the description carries the burden of explaining behavior. It describes how the AR tool works (phone camera, A4 reference scale) and what the visualizer does (renders in uploaded photo), but does not mention return format, permissions, or side effects. Adequate for a simple URL retrieval tool, but not deeply transparent.

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 three sentences, front-loaded with the primary purpose, and includes essential details without redundancy. Every sentence contributes meaning, making it highly concise and well-structured.

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

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

The description adequately explains the tool's context and usage for selection and invocation. However, with no output schema, it does not explicitly state that the tool returns a URL, which is implied by the name but could be clearer. Overall, complete enough for the tool's simplicity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minor value by explaining the mode options ('measure', 'visualize', 'both') and giving a product_id example, but largely repeats what the schema already states. It does not significantly deepen parameter understanding.

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

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

The description clearly states the tool's function: 'Surface the AR measurement tool or product visualizer' with specific use cases (measuring windows, previewing blinds). It distinguishes this tool from siblings by focusing on AR/visualizer functionality, which no other sibling addresses.

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 explicitly states when to use the tool: 'when a customer wants to measure their window or preview a blind in their room.' It does not explicitly contrast with alternatives, but the sibling set clearly lacks any AR/visualization tool, so usage context is well 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?

With no annotations, the description carries the full burden and does well by disclosing the live nature of the cart, the included data fields, and the 24-hour inactivity expiration. This provides a solid behavioral model, though it does not cover error cases like expired or missing carts.

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

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

The description is two sentences: the first states the core function and return contents, the second gives usage context and expiry. Every sentence earns its place, and the key information is front-loaded.

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

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

For a simple retrieval tool with one parameter and no output schema, this is complete. It explains what data the agent will receive, when to call it (after update_cart), and what the next step is (create_checkout), plus the cart validity constraint.

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

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

The schema offers only a bare cart_id string with 0% coverage, and the description minimally confirms retrieval by cart_id without adding format or source details. For a single, self-explanatory parameter, this is adequate but not enriching.

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 ('Retrieve') and clearly identifies the resource (live cart state by cart_id), listing the exact contents returned (full item list, totals, customer details). This distinguishes it from sibling tools like get_checkout or get_order, which operate on different resources.

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

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

The description explicitly instructs to call this tool after update_cart to confirm changes before proceeding to create_checkout, giving clear workflow sequencing. It does not explicitly mention when-not-to-use or alternative tools, but the contextual guidance is strong.

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?

No annotations are provided, so the description carries the burden. It discloses that payment_url is only returned 'if already minted' and lists the exact fields returned. However, it does not explicitly state read-only behavior or error conditions, so a perfect 5 is not warranted.

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 accomplish multiple goals: state function, list return values, and provide usage scenarios. No wasteful words, and the most important information is front-loaded.

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

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

For a simple one-parameter getter, the description fully covers return values, conditional behavior, and usage timing. It even mentions the 'already minted' edge case, making it contextually complete.

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

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

The single parameter checkout_id is only referenced by name with no additional format or provenance details. Since schema coverage is 0%, the description should compensate but only restates the parameter 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 uses a specific verb 'Poll' and identifies the resource 'checkout by checkout_id'. It clearly lists return contents and references sibling tools complete_checkout and update_checkout, differentiating its purpose.

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

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

Explicitly states when to use: 'before calling complete_checkout' and 'if complete_checkout was already called'. This provides clear context and alternatives, making it easy to decide when to invoke this tool.

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

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

With no annotations, the description fully carries the behavioral disclosure burden. It discloses production duration, holiday handling, return fields, customer-safe summary language, and the variability of transit time. This is exceptionally transparent for a simple estimate tool.

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

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

Three sentences, each adding essential information. The description is front-loaded with the core action and flows logically into constraints, return values, and usage guidance. No redundant words or repetition of schema details.

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 no output schema, the description covers return fields and their purpose, explains the specific business logic (production days, holidays), and gives user-facing guidance. Fully complete for a simple one-parameter tool.

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

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

The schema already provides 100% coverage for the single parameter, including type and default behavior. The description adds no new parameter-level semantics beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource ('Estimate when a new order will be dispatched') and clearly distinguishes it from sibling tools by focusing on production timeline and customer-facing dispatch estimates. It leaves no doubt about what the tool does.

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

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

Explicitly states when to call ('when a customer asks when will it arrive?') and gives a strong exclusion ('Never quote a final delivery date'). It also clarifies the context of production working days and holiday exclusions, making usage boundaries clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the soft-auth mechanism, the anti-lookup safeguard, and the return fields including payment status, production status, and dispatch date. This is rich behavioral context beyond what the schema provides.

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

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

The description is two sentences long, front-loaded with the primary purpose and followed by necessary constraints and return details. Every sentence contributes value with no redundancy.

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

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

For a simple read operation with 2 parameters and no output schema, the description covers the key return values (payment status, production status, dispatch date) and the auth constraint. It does not explicitly outline alternative tools for non-confirmed orders, but the context signals are sufficient for a low-complexity 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?

With 0% schema description coverage, the description compensates by explaining order_id as the identifier and customer_email as a soft-auth field that must match the order record. This adds meaningful semantics beyond the bare string type definitions, though it leaves basic formatting to be inferred.

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

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

The description clearly states the tool retrieves a confirmed order's status, items, and payment details, using a specific verb and naming the resource. It also distinguishes this tool from siblings like get_cart and get_checkout by specifying 'confirmed order'.

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 specifies that customer_email is required and must exactly match the order record, which is a clear prerequisite for using the tool. It does not explicitly name alternatives or exclusions, but the context of confirmed orders and the soft-auth requirement gives clear usage 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?

With no annotations, the description carries the burden of disclosing behavior. It clearly indicates a read-only listing operation ('List... Returns...'), specifies the exact return contents (Yoco and Ozow with capabilities), and describes the downstream usage. It does not explicitly state side effects or auth requirements, but for a simple getter, the behavioral transparency is strong.

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 three concise sentences, each earning its place: the first states the core purpose, the second details the return contents, and the third gives usage triggers and downstream context. It is front-loaded with the key information and has zero waste.

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

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

For a simple list tool with no output schema, the description adequately explains what the tool returns (the two processors and their capabilities) and how the result is used (to inform the payment_method field). It could be slightly more complete by mentioning possible edge cases (e.g., no payment methods available) but is otherwise sufficient for an agent to select and invoke the tool correctly.

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

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

The input schema already covers the single optional parameter with a clear description ('Optional. For future per-handler limit filtering.'), so schema coverage is 100%. The main description does not add parameter-level details beyond what the schema provides, which aligns with the baseline score of 3.

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

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

The description begins with 'List available payment processors and their capabilities,' which clearly states the tool's action and resource. It goes further to name specific processors (Yoco and Ozow) and their capabilities, making it unmistakable what this tool does and distinguishing it from sibling tools like get_checkout or create_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?

Explicit usage guidance is provided: 'Call when the customer asks ‘how can I pay?’ or before presenting options.' It also explains the result is used to inform the payment_method field in create_checkout and complete_checkout, giving concrete context on when and why to invoke this tool.

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

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

With no annotations, the description carries the full burden. It adds valuable details: exact price, VAT included, and return fields. However, it does not disclose the behavioral impact of the province parameter (which changes contact details based on location) or any potential limitations or side effects. This is a notable gap for a tool with no annotation safety profile.

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

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

The description is three sentences: purpose, required inputs and returns, and the next step in the workflow. It is front-loaded with the core action, has no filler, and every sentence earns its place.

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

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

There is no output schema, so the description rightly explains returns (unit_price_zar, total_price_zar, VAT included). It also provides workflow context. It omits the province effect on output and error handling, but for a straightforward price lookup, the description is adequate and complete enough.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds one useful nugget: product_id should come from search_products or lookup_catalog. It does not clarify the semantics of finish, province, or quantity beyond what the schema already says, providing no extra interpretive value.

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: 'Get an exact ZAR price for a product at specific dimensions.' It clearly distinguishes the tool from siblings like get_product and get_delivery_estimate by focusing on pricing and dimension-based calculation. It also mentions key return fields (unit_price_zar, total_price_zar), leaving no doubt about its purpose.

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

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

The description provides clear usage context: it requires product_id from search_products or lookup_catalog, and instructs to call configure_product next to lock in colour and mount type before cart creation. It does not explicitly name alternatives or when-not-to-use scenarios, but the workflow direction is clear and helpful.

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?

With no annotations, the description carries the burden. It discloses a read-only fetch and enumerates return contents: colours, in-stock status, materials, features, and maximum dimensions. It also clarifies it is a pre-commit validation step. It does not discuss error behavior, but for a simple read tool this is adequate.

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

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

Two sentences, front-loaded with the action and object. Each sentence adds new information: what it fetches, what it returns, and when to use it.

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

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

For a one-parameter tool with no annotations and no output schema, the description is sufficient: purpose, input format, output content, and workflow with configure_product are covered. It could mention stock-only alternatives but is not 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?

Schema has 0% description coverage and product_id is just a string. The description compensates by saying 'by id' and giving realistic slug examples (roller-blockout, venetian-25mm-aluwood), which clarify the expected ID 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?

Description states 'Fetch complete details for one product by id' and gives concrete id examples. This clearly distinguishes it from search/lookup siblings by focusing on single-product retrieval.

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

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

Provides explicit guidance: 'Use before configure_product to confirm a colour exists and is in stock before committing.' This gives a clear workflow context, though it does not explicitly list when not to use this tool versus alternatives like check_colour_stock.

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?

With no annotations, the description carries the burden of disclosing behavior. It reveals output structure (product_id with rationale), input validation (primary_concern must be one of...), and a special routing behavior for security concerns. However, it does not explicitly state whether the operation is read-only or mention any side effects, though the verb 'translate' implies non-mutating 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?

The description is three sentences, front-loaded with the core purpose, then constraints, then output and routing. Every sentence adds new information with no redundancy or fluff.

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

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

Given no output schema, the description explains the return value and how to proceed, includes necessary constraints for input values, and highlights a routing exception. This is complete for a tool with 5 simple parameters and one required enum, fitting well within the purchase flow 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?

Schema coverage is 0%, so the description fully compensates by mapping each optional parameter (room, location, budget, aesthetic) and listing the required enum values for primary_concern. It adds meaningful examples (bedroom, lounge) and clarifies that budget refers to max_budget_zar, giving agents a clear understanding of what each parameter means.

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 'translate' and clearly identifies the resource (customer concern to product recommendation). It enumerates valid primary_concern values and distinguishes the tool's role from siblings like search_products by emphasizing recommendation generation and noting a routing exception for security concerns.

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

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

The description provides explicit when-to-use context ('Translate a customer's primary concern'), an alternative path for security concerns (brochure MCP, Garden Route customers only), and next steps (pass recommendation to get_price or configure_product). This gives clear guidance on when to invoke this tool and how it fits into the broader flow.

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?

No annotations are provided, so the description carries the transparency burden. It fully discloses the routing logic including location-based phone numbers, which is the core behavioral trait. However, it doesn't clarify the return format (e.g., a URL string) or that no message is actually sent, which would be useful additional 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?

Two sentences, front-loaded with the action and outcome. Every sentence adds value: the first defines the tool, the second provides routing details and usage guidance. No wasted words.

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

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

Given the tool's moderate complexity (routing logic) and lack of output schema, the description covers the essential business rules well. However, it omits the return value structure (e.g., deep link URL) and the fact that all parameters are optional, leaving minor gaps for agent decision-making.

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 75%, so baseline is 3. The description reinforces the location parameter's routing impact, but the schema already covers this. It adds no extra meaning for message, customer_name, or product_context beyond schema descriptions, so it doesn't exceed the baseline.

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 ('Generate') and resource ('pre-filled WhatsApp deep link'), clearly stating the tool's function. It distinguishes itself from siblings like checkout or enquiry tools by focusing on WhatsApp handoff, which is absent in all sibling tools.

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

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

Explicitly states when to use: 'when the customer prefers human assistance or when self-serve checkout isn't appropriate'. This gives clear context, though it doesn't name alternative tools or specify when not to use, which would make it a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return fields (id and product_url), which is useful, but does not mention whether the operation is read-only, any auth requirements, or limitations like exact matching or case sensitivity. For a lookup tool, the risk is low, but the behavioral disclosure is incomplete.

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 three sentences with the main purpose front-loaded. Each sentence adds value: what the tool does, when to use it, and what it returns. No fluff.

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

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

Given the absence of an output schema and annotations, the description covers the basic purpose, usage, and return fields. However, it does not explain parameter interactions (e.g., AND vs OR), optionality, or value formats. For a 4-parameter tool with no output schema, more detail is expected to be 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 coverage is only 25% (only category has a description). The description merely repeats the parameter names without adding meaning: 'colour name' does not specify accepted formats (e.g., exact match, partial), and max_width_mm/max_height_mm are left as plain numbers without units or constraints. It does not compensate for the missing schema descriptions.

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

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

The description uses a specific verb ('filter') and resource ('catalogue'), and clearly lists the filter dimensions (category, colour, width, height). It also distinguishes itself from the sibling tool by explicitly naming search_catalog as the alternative for open-ended queries.

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 states the ideal use case ('when the customer has stated a blind type') and explicitly directs to search_catalog for natural language queries. This provides clear when-to-use and alternative guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses the output ('Returns a pre-filled WhatsApp link to the claims team') and mentions verification ('verified South African retailer prices'). However, it is ambiguous whether the tool actually submits a claim or merely generates a link, and it does not mention side effects, auth needs, or failure modes. This gap prevents a higher score.

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

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

The description is four sentences, front-loaded with the core action, and every sentence earns its place: purpose, context, output, exclusions, and requirements. It is concise without being sparse and has a logical flow.

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 no output schema, the description explains the return value (pre-filled WhatsApp link) and provides key context about eligibility and exclusions. It covers the essential use case. However, the ambiguity about whether the claim is actually submitted on the backend and the lack of detail on the other optional parameters (though schema covers them) leave minor gaps, keeping it a 4.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds only that 'product_id and competitor_price_zar' are required, which reinforces the schema's required list but provides no new meaning or usage nuances for the other six parameters. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Submit a price match claim when the customer has found the same blind cheaper elsewhere.' It specifies the verb (submit), the resource (price match claim), and the trigger condition. It also distinguishes itself from siblings like get_price and get_whatsapp_handoff by focusing on claim submission.

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

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

Provides clear when-to-use context ('when the customer has found the same blind cheaper elsewhere') and explicit when-not-to-use exclusions ('Not applicable to: Blinds Direct (same supplier), clearance or flash-sale prices, or out-of-stock items'). It also states the minimum required fields. However, it does not explicitly name alternative tools, so not a full 5.

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

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

With no annotations, the description carries the full behavioral burden. It discloses key behaviors: swatches ship with order placement, are not sent as standalone samples, and are capped at 5 codes. It also explains the expected handling of pre-order requests. This is strong for a simple tool, though it doesn't mention response behavior or side effects.

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 three sentences long, front-loads the purpose, then adds the key behavioral detail and a customer-handling guideline. No wasted words.

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

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

For a simple request tool with no output schema and no annotations, the description covers the purpose, constraints, and edge-case handling. It lacks details about response format or post-request effects, but these are not critical for this tool. Overall complete.

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

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

The schema covers 67% of parameters with descriptions, including swatch_codes with max 5. The description reinforces the 5-code cap and the context that swatches are colour swatches tied to an order. It doesn't add significant new meaning to the other parameters beyond what the schema provides, so a score of 3 is appropriate.

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

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

The description clearly states the tool registers up to 5 colour swatches to be dispatched with the customer's order. It uses a specific verb ('register') and resource ('colour swatches'), and distinguishes from sibling tools by focusing on swatch requests. The 5-code cap adds clarity.

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 explicitly provides usage guidance: swatches are sent with the order, not standalone, and includes an instruction to guide customers to place an order first if they ask before ordering. This clearly delineates when to use the tool and when not to, fulfilling the dimension well.

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?

With no annotations, the description carries the full transparency burden. It discloses the return fields (id, name, category, description, product_url) and the scope ('full catalogue'). However, it does not mention potential large result sets, pagination, or whether the query parameter is optional, leaving minor gaps in behavioral disclosure.

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

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

The description is three sentences, each earning its place: purpose with examples, return fields, and usage alternatives/next steps. It is front-loaded and free of redundancy, making it easy for an agent to parse quickly.

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

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

For a simple one-parameter tool with no output schema, the description is quite complete: it explains purpose, return fields, when to use vs. alternatives, and integrates with downstream tools. It lacks only minor details like response format or result limits, which are not critical given the tool's simplicity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying that the query is for open, natural-language searches (e.g., 'blockout for bedroom'), going beyond the schema's simple example. It reinforces the free-text nature and provides richer usage examples, which aids parameter understanding.

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

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

The description clearly states the tool's function: 'Free-text search across the full catalogue' with examples of valid open queries. It distinguishes itself from the sibling tool lookup_catalog by explicitly directing filtered queries there, and it names downstream tools (get_product, get_price) for continued use.

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 says when to use this tool ('use for open queries') and explicitly points to an alternative for structured filtering ('For filtering by category, colour, or dimensions use lookup_catalog instead'). It also provides a clear next step ('Pass the returned id to get_product or get_price'), giving the agent actionable usage guidance.

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

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

No annotations are present, so the description carries the full burden. It discloses the return fields (product_id, name, description, features, in-stock colour count) and implies a read-only search operation. It lacks explicit statements about combined filter behavior or result ordering, but the core behavior is sufficiently transparent.

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 use case, then filters, return fields, and next-step guidance. Zero fluff, every sentence earns its place.

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

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

Given no output schema, the description adequately informs the agent of expected return fields. It also connects to downstream tools. It does not mention how multiple filters interact or what happens if no filters are specified, but these are minor gaps for a search tool with this schema richness.

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

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

The input schema already provides 100% coverage with detailed descriptions for all parameters, including the blind-type list, partial match for colour, and unit clarification for dimensions. The description adds little beyond what the schema already states, so the baseline score of 3 applies.

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

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

The description clearly states the tool searches products by listing filter criteria (blind type, colour, dimensions) and explicitly frames it as the tool to use before a product ID is known. This distinguishes it from ID-based tools like get_product and guides the invocation correctly.

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 an explicit condition for use ('when the customer hasn't specified a product ID yet') and suggests next steps (get_price, configure_product). It does not explicitly rule out sibling tools like search_catalog or lookup_catalog, but the scope is clear enough for an agent to choose appropriately.

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?

No annotations are present, so the description carries the burden. It discloses legacy status, auth requirements, and the 24-hour team response time. It doesn't explicitly state that this creates an enquiry record, but the verb 'submit' and the follow-up context imply it. Missing details like side effects are partially covered by the strong usage guidance.

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

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

Three sentences, front-loaded with the preferred alternative and clear usage condition. No filler; each sentence provides unique operational value: preference, condition, and required inputs.

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 a nested product_config and no output schema, the description covers the main decision points: when to use, what to pass, auth, and expected response time. It doesn't describe return values, but the 'team responds within 24 hours' provides some outcome context. Moderate complexity justifies a 4.

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

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

Schema coverage is 100% with descriptions for all properties. The description adds valuable cross-tool context by stating that product_config should be a configure_product output and lists the required customer fields. This relationship is not in the schema.

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

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

The description states a specific verb-resource pair ('submit an enquiry') and clearly distinguishes it from the checkout flow by explaining that it's for sales team follow-up by email. It also positions the tool as legacy, giving clear scope.

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

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

Explicitly says to prefer the open UCP flow (create_cart → create_checkout → complete_checkout) for credentialless checkout, and to use submit_enquiry only when a sales team follow-up is desired. Also notes the Bearer token requirement, providing clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden. It discloses the effect of each operation (append, drop by 0-based index, replace full list, empty) and the customer merge behavior, plus the checkout-in-progress restriction. This gives the agent a solid behavioral model, though it doesn't cover edge cases like out-of-bounds indices or error returns.

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

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

Four sentences, each with a distinct role: purpose, operation semantics, customer behavior, and usage guidance + constraint. No filler, front-loaded purpose.

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 5-parameter tool with no output schema and no annotations, the description explains the core behaviors and provides a verification step. It could elaborate on return values or prerequisites for items, but overall it is complete enough for an agent to use the tool correctly.

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

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

Schema description coverage is only 20% (indices only). The description compensates by explaining the op enum values, that items are used for add/set, and that customer merges name/email/phone. This adds meaning beyond the raw schema for most parameters.

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

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

The description states 'Modify an open cart before checkout' — a specific verb and resource, then details each op (add, remove, set, clear) and the customer merge. It distinguishes from siblings by scoping to open carts and excluding carts with checkout in progress.

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

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

It gives clear usage context: 'before checkout' and the constraint 'Cannot modify a cart that already has a checkout in progress.' It also advises 'Call get_cart afterwards to confirm,' establishing a workflow. No explicit alternative tool names are mentioned, but the constraint provides a when-not.

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?

With no annotations, the description carries full burden and discloses the mutating action, the return value (updated checkout state), and an error condition for invalid states. It falls short of fully detailing permissions or reversibility, but the core behavior is well covered.

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

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

Three sentences, each with a distinct role: action/context, return value, and error behavior. No filler or repetition, and the most important information is front-loaded.

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

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

The description effectively covers purpose, usage, output, and a key error condition, making it sufficient for a straightforward update tool. It doesn't detail the structure of the returned checkout state, but that is a minor omission given the tool's simplicity.

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

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

The description compensates for 0% schema coverage by specifying the expected fields of the customer object (name, email, phone, address) and enumerating payment methods. It does not elaborate on checkout_id, but that parameter is self-explanatory from its name and requirement.

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 (correct customer details or switch payment_method) on a specific resource (unpaid checkout), and clearly distinguishes from sibling tools like complete_checkout and cancel_checkout by framing it as a pre-completion step.

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

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

It explicitly says when to use it ('on an unpaid checkout before calling complete_checkout') and implies when not to use it via the error condition for already paid or cancelled checkouts. This gives clear contextual guidance relative to the checkout lifecycle.

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