PuroAir

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

With no annotations provided, the description takes full responsibility for behavioral disclosure. It clearly states that the tool does NOT charge or place an order, and that it returns a URL for the shopper to complete payment. It also warns against using it for out-of-stock items, revealing a limitation that could affect user experience.

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 well-structured and concise: a clear one-sentence summary, a prominent IMPORTANT note, usage instructions, and parameter docs in a compact format. Every sentence earns its place without 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 covers all necessary aspects: what it does, what it returns, when to use it, how to use parameters, and important caveats. It integrates well with the output schema (which confirms the return fields) and sibling tools, making it fully actionable for an AI 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?

The input schema has 0% coverage, so the description must compensate. It does so effectively by explaining that 'sku' should come from list_products / search_products, and that 'quantity' defaults to 1. This adds meaningful context beyond the raw schema, helping the agent source correct parameter values.

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

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

The description clearly states the tool's function: 'Add a product to a cart and return its checkout URL.' It uses a specific verb and resource, and explicitly distinguishes itself from sibling tools by noting that create_checkout is for multiple items and check_stock is for availability checks.

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 usage guidance: 'Use for "add X to my cart" / "I want to buy X".' It also names alternatives and exclusions: 'For multiple items in one cart, use create_checkout. Verify availability with check_stock first.' This clearly tells the agent when and when not to use 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 discloses behavioral traits: it queries live store data (Shopify/Amazon/WooCommerce), has a demo mode (`live: False`), handles errors when SKU is missing or store unreachable, and notes that stock count may be a boolean or an exact count with `low_stock` hint. This goes beyond what annotations would provide.

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

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

Although lengthy, the description is efficiently organized with a headline purpose sentence, a usage paragraph, and clearly labeled Args/Returns/Example sections. No sentence is wasted; every part earns its place.

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

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

The description is complete for a one-parameter tool: it explains when to use, what the parameter means, what the return fields are (including `live`, `error`, `low_stock`), and provides a full example. Despite having an output schema, the description adds context about provenance, demo mode, and store integrations.

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 provides only the name and type of `sku` with no description. The tool description compensates fully by explaining it is the product SKU field returned by list_products/search_products and gives an example ('RED-WIDGET-001'). This adds crucial semantic meaning.

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

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

The description opens with a specific verb+resource+scope: 'Check LIVE inventory, price, and same-day shipping for ONE known SKU.' It explicitly distinguishes from sibling tools by stating when to use get_price, get_product_details, and discovery tools, making its unique purpose clear.

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

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

The description provides explicit when-to-use guidance for common shopper queries ('is it in stock', 'how many are left', etc.) and mandates calling before recommending or adding to cart. It also names alternatives: 'For discovery use those tools; for full attributes use get_product_details; for price only use get_price.'

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 a critical behavior: the tool does not charge or place an order, only returns a checkout URL. However, it does not mention other potential side effects like whether a cart is persisted or if stock is checked, leaving some behavioral gaps.

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 succinct, with a clear first sentence, a crucial behavioral note, and a compact Args section. It avoids redundancy and uses formatting (bold, code) to direct attention to key points.

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 one parameter and an output schema, the description covers purpose, usage, parameters, and the key non-charging behavior. It lacks explicit mention of error cases or prerequisites, but these are not heavily required for such a simple tool. Overall, it provides sufficient context for an AI 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?

The schema provides no descriptions (0% coverage), but the description compensates by specifying the exact structure: `items` is a list of `{"sku": str, "quantity": int}` with a default quantity of 1. This gives agents enough detail to construct valid arguments without relying on schema descriptions.

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

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

The description clearly states 'Build a multi-item cart and return its checkout URL', using a specific verb and resource. It differentiates from sibling tools like add_to_cart by focusing on multi-item cart creation and explicitly notes it does not charge or place an order. This makes the tool's purpose unambiguous and well-scoped.

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 says 'Use to assemble a basket the shopper asked for', giving a direct usage context. It also warns 'IMPORTANT: this does NOT charge or place an order', which clarifies when not to use it. While it doesn't name sibling alternatives, the guidance is sufficient to avoid misuse.

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 behavioral burden. It discloses that the price is the store's CURRENT selling price (including sales), that returns are limited to price/currency (plus sku/live), and that missing SKUs yield price 0.0 with an error. Minor inconsistency: the example omits the 'live' field, but overall transparency is good.

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 well-structured with a clear opening, usage notes, args, returns, and example. Every section adds value, and the front-loading effectively communicates the core purpose. Length is justified by the useful guidance.

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

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

The tool is simple with one parameter, and the description covers purpose, usage conditions, return format, error handling, and example. It also clearly distinguishes from siblings, making it 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 input schema has only a required 'sku' string with no description, so the description compensates well. It explains that sku is the product SKU, referencing the 'sku' field from list_products, and provides a concrete example.

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: 'Get the current price (and currency) for a product SKU.' It also explicitly distinguishes from sibling tools by noting 'for stock/shipping use check_stock, for full details use get_product_details,' 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?

The description provides explicit when-to-use guidance: 'Use when a shopper asks "how much is X" and the agent already has the SKU (from list_products / search_products).' It also names alternatives and warns against using remembered prices, which clearly directs the agent.

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

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

With no annotations, the description carries the transparency burden. It discloses the returned fields, the edge case where 'found' is False for missing SKUs, and the optional inventory_quantity alternative. It does not mention authorization or rate limits, but for a simple read tool, the 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?

The description is well-structured with sections for purpose, usage, args, and returns. Every sentence adds value, and it is front-loaded with the core purpose. No filler or redundancy.

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

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

Given a single parameter, an output schema, and sibling context, the description covers the necessary behavior: purpose, usage, parameter semantics, and return details including edge cases. It even provides guidance on how to use the returned fields for suitability questions.

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 description coverage is 0%, so the description fully compensates. It defines 'sku' as 'Product SKU — e.g. the ``sku`` field returned by list_products', giving both meaning and an example source, which is clearer than the bare schema.

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

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

The description clearly states the tool gets full product details for a SKU, and distinguishes it from siblings by calling it 'a verifier, not a browser' and referencing list_products/search_products for discovery. The verb 'Get' and resource 'product details' are specific and 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 states when to use: 'when a shopper wants depth on a SPECIFIC product the agent already has a SKU for' and points to alternatives: 'For discovery, call those first.' This provides clear when-to-use and when-not-to-use guidance, mentioning sibling tools.

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

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

With no annotations provided, the description carries the full burden, and it delivers. It discloses an important behavioral filter: 'Only sellable products are returned (drafts/archived are excluded).' It also details the return shape, including pagination fields (next_cursor, has_more) and provenance flags (live/source), which goes beyond the minimal 'list' expectation.

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 well-structured and front-loaded. The first sentence states the core purpose, followed by usage guidance, a recommended flow, and clearly labeled Args/Returns sections. Every sentence earns its place; it is concise enough despite being detailed, with no redundant 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?

Given the tool's simplicity (2 params, no annotations) and the presence of an output schema (implicitly described in Returns), the description is fully complete. It covers when to use it, how to paginate, what gets returned, and how it fits into a larger workflow with sibling tools. The description is sufficient for an agent to select and invoke this tool without ambiguity.

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

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

The schema has no descriptions (0% coverage), so the description must compensate, and it does thoroughly. The Args section adds constraints and meaning: 'limit: Number of products to return (1-50, default 10)' adds the 1-50 range not present in the schema, and 'cursor: Opaque cursor from a previous response's next_cursor' explains its exact usage and how to omit it for the first page.

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 clear, specific statement: 'List products from the connected store, paginated.' It immediately identifies the verb (list), resource (products), and scope (connected store, paginated). It also distinguishes itself from siblings by framing it as the discovery/browsing tool versus verification tools like search_products or get_product_details.

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 this tool: 'Use this tool when an agent needs to DISCOVER products by browsing the catalog rather than VERIFYING a known SKU.' It also provides an explicit alternative: 'When the shopper's request contains matchable terms... prefer search_products.' The recommended flow (search_products/list_products -> get_product_details -> check_stock -> add_to_cart/create_checkout) 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 fully owns behavioral disclosure. It reveals that results match Shopify's native search, only sellable products are returned (excluded drafts/archived), and empty results are possible. It also advises using fewest distinctive words, adding practical behavioral context.

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

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

The description is structured logically: purpose, use cases, search tips, fallback, flow, args, returns. Despite being moderately long, every sentence adds value and the key purpose is front-loaded. It is appropriately sized for the tool's complexity.

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

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

The description covers purpose, usage, behavioral quirks, parameter semantics, and return shape (same as list_products, empty when no matches). It even provides a recommended flow, making it complete for a 2-param tool with no annotations and an output schema.

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

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

Schema coverage is 0% and the description compensates with an Args section: 'query: Keyword or phrase to match' and 'limit: Max products to return (1-50, default 10)'. This adds meaning beyond the raw schema, including a range not present 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 begins with a clear statement 'Search products in the connected store by keyword', specifying the verb, resource, and method. It also distinguishes itself from list_products by explaining when to use search versus listing, and explicitly mentions fallback to list_products.

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 when-to-use guidance: for queries with specific terms matching titles/tags. It also gives a fallback strategy ('retry with a broader term or fall back to list_products') and even a recommended flow, clarifying when to use this tool versus siblings.

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