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 environment variable fallback behavior (W3SHIP_PUBLIC_KEY), which is valuable operational context. However, it omits other critical behavioral traits like idempotency, error cases (e.g., cart not found), or side effects beyond the addition itself.

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 total. The first establishes purpose; the second explains the optional cartId behavior. Every sentence earns its place with no redundancy or filler, efficiently front-loading the essential 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 complex nested object structure for 'item', lack of output schema, and absence of annotations, the description provides minimal viable context. It covers the primary action and cartId resolution, but leaves significant gaps regarding the item payload structure and return behavior.

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 50% (cartId described in schema, item is not). The description adds the specific environment variable name (W3SHIP_PUBLIC_KEY) for the cartId parameter, clarifying the fallback mechanism. However, it fails to compensate for the undocumented 'item' parameter structure, leaving the nested productOffering and quantity objects unexplained.

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

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

The description explicitly states 'Add an item to an existing shopping cart' with a specific verb (add) and resource (item). The word 'existing' effectively distinguishes this from the sibling create_cart tool, making the scope 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 implies usage constraints by specifying 'existing shopping cart' (suggesting the cart must already exist), and explains the W3SHIP_PUBLIC_KEY fallback mechanism. However, it lacks explicit guidance on when to use create_cart instead, or prerequisites like cart existence validation.

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. It discloses the buyer-side effect ('Provides the buyer with...'), but omits mutation details like idempotency, overwrite behavior, or the verification purpose of sellerAddress mentioned in the schema.

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

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

Two efficient sentences with zero waste. 'Seller tool:' front-loading immediately establishes context. Every word earns its place; no redundancy with schema or name.

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?

Adequate for a 4-parameter mutation tool with no output schema—it explains the action and primary side effect. However, gaps remain around error cases (e.g., invalid tracking numbers), return value structure, and whether the operation is idempotent.

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 100% coverage with clear descriptions. The description references 'tracking number and carrier' and implies the order target, reinforcing the schema, but adds no syntax, format details, or parameter relationships beyond what's in the schema properties.

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?

Clear verb ('Add'), resource ('shipping tracking info'), and scope ('to an order'). The 'Seller tool' prefix effectively restricts the audience. However, it doesn't explicitly differentiate from sibling 'track_shipment' (which likely queries tracking vs. adding it).

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

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

Provides implicit guidance via 'after shipping the item' (sequencing) and 'Seller tool' (role restriction). However, it lacks explicit 'when not to use' or named alternatives (e.g., whether to use this vs. updating an order).

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 provided, so description carries full burden. Successfully discloses return values ('whether approval is needed and the approval transaction') and environment requirement. However, lacks safety profile (read-only vs. state-changing), rate limits, or error handling behavior.

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

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

Three sentences with zero waste: purpose statement, return value disclosure, and prerequisite warning. Front-loaded with specific action verb and efficiently 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?

Given 100% input schema coverage and no output schema, the description adequately covers return behavior textually and documents the API key requirement. Minor gap: lacks safety classification (destructive vs. safe) which annotations would normally provide.

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%, establishing baseline 3. Description does not add parameter-specific semantics (e.g., valid token formats, amount precision), but the comprehensive schema makes this acceptable.

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?

Specific verb 'Check' + resource 'token approval' + domain 'Uniswap' provides clear purpose. Effectively distinguishes from sibling 'get_swap_quote' and non-crypto tools like 'create_cart' by specifying the Uniswap swapping context.

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

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

Implies workflow context ('for swapping') and prerequisite (UNISWAP_API_KEY), but lacks explicit when-to-use guidance versus sibling 'get_swap_quote' or confirmation that this should be called before executing swaps. No exclusion criteria provided.

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

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

With no annotations provided, the description carries full disclosure burden and succeeds in explaining cost structures (free items vs shipping costs), identity verification requirements, and claim limits. It omits explicit mutation confirmation or idempotency details.

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

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

Three dense sentences efficiently cover purpose, pricing structure, and prerequisites without repetition. Every clause adds unique information (cost breakdown by fulfillment method, wallet limits, identity requirements).

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 100% schema coverage and no output schema, the description adequately covers the tool's complexity, including conditional logic for fulfillment methods. It could explicitly mention the pickupLocationId requirement for multi-location scenarios, though the schema handles this.

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?

While schema coverage is 100% (baseline 3), the description adds crucial business context: it explains that 'promotional' means $0, clarifies the cost implications of 'ship' vs 'pickup' choices, and explains identity requirements that bridge publicKey and fulfillmentChoice 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 opens with a specific verb ('Claim') and resource ('FREE promotional listing'), clearly distinguishing this from sibling purchase tools like create_order or confirm_payment by emphasizing the $0 cost and promotional nature.

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

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

It provides clear prerequisites ('Must have a registered W3Ship/Dah.mx identity') and constraints ('One claim per wallet') that establish when the tool is applicable, though it doesn't explicitly name sibling alternatives to avoid.

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 successfully discloses that this is a state-mutating operation ('update the order status'). However, it lacks details on validation logic (e.g., confirmation depth, amount verification), error scenarios, or side effects like seller notifications.

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 well-structured sentences with zero waste. The first states the core action; the second provides the workflow context and prerequisites. Information is front-loaded 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?

Given the 100% schema coverage and clear workflow description, the essential information for successful invocation is present. However, for a financial transaction tool with no output schema or annotations, it lacks guidance on error cases (invalid hash, wrong chain) or what indicates successful verification.

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%, establishing a baseline of 3. The description adds workflow context ('provide the transaction hash here') that reinforces the parameter purpose, but does not add syntactic details or format constraints beyond what the schema already provides (e.g., '0x...' for txHash).

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 specific action ('Submit an on-chain payment transaction for verification') and the outcome ('update the order status to paid'). It effectively distinguishes this from sibling tools like create_order (which precedes payment) and get_order (read-only).

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 temporal guidance ('After paying the seller... provide the transaction hash here') establishing the correct sequence in the workflow. However, it does not explicitly mention alternative tools for different payment scenarios or failure recovery.

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 provided, so description carries full burden. Discloses authentication behavior (env var vs SLH-DSA/ECDSA hex keys) well, but lacks disclosure on return values, idempotency, side effects, or cart persistence 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?

Two sentences with zero waste. Front-loaded with purpose (TMF663 cart creation), followed immediately by configuration logic. Every word earns its place.

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

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

Moderate complexity tool with no output schema. Description adequately covers the non-trivial authentication flow but fails to document the customer parameter structure or hint at return value expectations.

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

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

Schema coverage is 50%. Description adds value for 'id' parameter (key algorithm types SLH-DSA/ECDSA, conditional requirement logic) beyond schema. However, completely omits documentation for the 'customer' object and its sub-fields (id, 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?

Description uses specific verb 'Create' with resource 'TMF663 shopping cart'. The TMF663 reference distinguishes it from generic carts, and clearly differentiates from siblings like get_cart (retrieval) and delete_cart (deletion).

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 conditional logic for when the 'id' parameter is required versus when W3SHIP_PUBLIC_KEY environment variable suffices. Could improve by distinguishing from sibling create_order or create_listing 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 disclosure burden. It successfully conveys the permissionless nature ('no merchant onboarding needed') and payment mechanism (wallet address), but fails to disclose critical behavioral traits like whether this creates an on-chain transaction, associated gas fees, listing immutability, or activation timing.

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 consists of two highly efficient sentences. The first states the core action, while the second front-loads the most critical constraints (no onboarding) and required parameters. There is no redundant or wasted language.

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 high complexity (16 parameters) and lack of output schema or annotations, the description is minimally adequate but misses opportunities to guide the agent through the tool's significant capabilities—specifically the promotional item mode (isPromo, promoQuantity) and fulfillment logistics (fulfillmentType, pickupLocations) which represent distinct usage patterns beyond basic selling.

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?

While the input schema has 100% description coverage, the description adds valuable context beyond the schema: it highlights the cryptocurrency nature (USDC/ETH/etc) and clarifies that sellerAddress is specifically 'for payment'. This semantic framing helps the agent understand the crypto-commerce context that raw parameter descriptions don't convey.

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 provides a specific verb (Create) and resource (P2P marketplace listing) that clearly identifies the tool's function. The 'P2P marketplace' qualifier effectively distinguishes it from sibling tools like 'create_order' or 'add_item' by positioning it as a seller-side listing creation tool.

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

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

The phrase 'Anyone can sell items — no merchant onboarding needed' provides implicit guidance about when to use this (for casual selling without formal merchant setup). However, it lacks explicit when-not-to-use guidance or differentiation from similar tools like 'add_item', and doesn't clarify the relationship to promo-specific workflows.

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 disclosure burden. It successfully indicates side effects ('initiate fulfillment') and state change ('confirmed Order'), but omits critical mutation details: idempotency behavior, whether the cart is deleted post-conversion, error handling, or payment prerequisites.

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?

Single sentence with zero waste. Information is front-loaded with the action ('Convert'), followed by input/output resources, standard reference (TMF622), and side effects ('initiate fulfillment'). Every clause 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?

Adequate for the simple single-parameter schema, but gaps remain given the lack of annotations and output schema. The description omits what the operation returns (order ID? full object?) and the cart lifecycle outcome (persistence vs. deletion), which are important for a state-changing operation.

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

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

Schema description coverage is 100%, establishing a baseline of 3. The description references 'Shopping Cart' which conceptually aligns with the 'cartId' parameter, but adds no specific syntax, format constraints, or guidance on obtaining the ID beyond what the schema already provides.

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 specific verbs ('Convert', 'initiate') and clearly identifies the resource transformation (Shopping Cart → confirmed Order). It distinguishes effectively from siblings like 'create_cart' (creates empty carts) and 'get_order' (retrieves orders) by specifying this converts existing carts into confirmed orders.

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

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

The description implies prerequisites by referencing 'Shopping Cart,' suggesting a cart must exist first, but lacks explicit workflow guidance. It does not clarify the sequence relative to siblings like 'confirm_payment' or 'add_item,' nor does it state when NOT to use it (e.g., empty carts, unpaid carts).

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 of behavioral disclosure. While 'Delete' implies destruction, it fails to clarify if the operation is permanent, what happens to items contained in the cart, or whether it triggers cancellation of associated orders. No mention of required permissions or reversibility.

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?

Extremely concise at four words with no redundancy. However, for a destructive operation, this brevity borders on under-specification; nonetheless, the sentence earns its place and is appropriately 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?

Inadequate for a destructive operation with no annotations and no output schema. The description omits critical safety context such as permanence, side effects on cart items, or relationship to the order creation workflow (given sibling tools like create_order and confirm_payment).

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 100% description coverage for the 'id' parameter ('Public key ID of the cart'). The description adds no additional parameter context, but with complete schema coverage, the baseline 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 uses a specific verb ('Delete') and resource ('shopping cart'), making the basic purpose immediately clear. It implicitly distinguishes from siblings like get_cart (read) and create_cart (write), though it does not explicitly differentiate from remove_listing or clarify the cart vs. order lifecycle.

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

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

No guidance provided on when to use this versus alternatives (e.g., whether to use this for abandoned carts versus cancelling active orders), nor are prerequisites stated (e.g., whether the cart must be empty or if it affects pending checkouts).

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 provided, so description carries full burden. It discloses the return format ('public key hex') and testing purpose, but fails to clarify critical behavioral aspects: whether the private key is returned, stored server-side, or discarded, and whether multiple calls create conflicting keys.

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 well-structured sentences with zero waste. Front-loaded with the core action ('Generate...'), followed by integration context ('can be used with create_cart'), and concluding with use-case rationale ('without a real wallet'). 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?

Appropriately complete for a zero-parameter tool lacking output schema. Covers generation purpose, output format, and integration with sibling tools. Minor gap regarding private key disposition and persistence, which would be valuable given the cryptographic nature of the operation.

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

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

Input schema contains zero parameters, establishing a baseline of 4 per evaluation rules. No parameter description is needed, and the description correctly focuses on behavior and output rather than inventing parameter documentation.

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

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

Description uses specific verb 'Generate' with clear resource 'demo ECDSA key pair' and scope 'for testing'. It distinguishes from siblings by emphasizing 'demo' and 'without a real wallet', clearly positioning it as a testing utility distinct from production wallet operations.

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

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

Provides clear context on when to use ('trying out the commerce flow without a real wallet', 'testing') and explicitly names sibling tool 'create_cart' as a consumer of the output. Lacks explicit negative guidance (e.g., 'do not use in production'), though this is strongly 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?

No annotations provided, so description carries full burden. Compensates well by disclosing return values (times, capacity, pricing, activity type) absent an output schema. However, missing operational details like whether data is real-time vs cached, rate limits, or timezone handling.

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

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

Three sentences, zero waste: sentence 1 states purpose, sentence 2 discloses return structure, sentence 3 defines applicable domains. Front-loaded with action verb. No redundant or filler text.

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 3-parameter query tool with no output schema, description adequately compensates by listing return fields and service domains. Would benefit from mentioning pagination (if many slots) or error cases (invalid dates), but covers core functionality well.

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

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

Input schema has 100% description coverage (locationId with examples, date format specified, activityId noted as optional). Description references 'location' and 'date' but adds no semantic details beyond the schema documentation. Baseline 3 appropriate since schema is self-sufficient.

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?

Excellent specificity with verb 'Get' + resource 'available session time slots' + scope 'for a location on a given date'. The examples of bookable services (VR, fitness, dining, salon) clearly distinguish this from sibling action tools like hold_slot, create_order, and list_bookings.

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 domain context by listing applicable service types (VR, fitness, dining, salon), implying this is a pre-booking availability check. However, lacks explicit guidance on workflow transition to hold_slot for reserving or create_order for purchasing, and doesn't state prerequisites.

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 provided, so description carries full burden. Adds valuable context about environment variable fallback behavior, but omits other behavioral traits like error handling when cart not found, read-only nature, or authentication requirements.

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 zero waste: first establishes purpose, second covers default behavior. Front-loaded with the essential action and appropriately sized for a single-parameter retrieval tool.

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

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

Adequate for a simple retrieval operation with one optional parameter. Captures the critical environment variable dependency. Could be improved by mentioning error behavior (e.g., what happens if cart doesn't exist), but sufficient given the tool's limited complexity and lack of 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 has 100% coverage and already documents the W3SHIP_PUBLIC_KEY fallback mechanism. Description repeats this information without adding semantic depth (e.g., ID format examples, validation rules) beyond what the schema provides. Baseline 3 appropriate for high schema coverage with minimal added description context.

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

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

Uses specific verb 'Retrieve' with clear resource 'shopping cart' and identifier type 'Public Key ID'. Distinct from siblings like create_cart, delete_cart, and get_order through precise resource naming.

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

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

Implies usage by documenting the W3SHIP_PUBLIC_KEY fallback mechanism, indicating when the id parameter can be omitted. However, lacks explicit guidance on when to use this versus sibling tools like create_cart or delete_cart.

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

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

With no annotations, description carries full burden. Discloses conditional return behavior (public key/type vs. configuration instructions), which is valuable. Missing: side effects, error conditions, or format details of the 'instructions' return value.

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

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

Two sentences with zero waste. Front-loaded with main action ('Show the currently configured identity'), followed by precise return value specification. Every clause 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?

Appropriately complete for a simple parameter-less getter. Compensates for missing output schema by describing both success states (key present vs. absent). Minor gap: lacks error handling description or return format specifics.

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?

Zero parameters present, establishing baseline 4. Description references W3SHIP_PUBLIC_KEY but as the resource identifier, not a parameter. No parameter documentation needed given empty input 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?

Clear verb 'Show' and specific resource 'configured identity (W3SHIP_PUBLIC_KEY)'. Clearly distinguishes from commerce-focused siblings (add_item, create_cart, etc.) as the sole identity/auth management tool. Minor gap: could explicitly state this is for authentication purposes.

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

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

Implies usage context through 'if set' conditional, suggesting it's for checking authentication status. However, lacks explicit guidance on when to use versus alternatives (e.g., generate_demo_key) or prerequisites for other operations.

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 of behavioral disclosure. While 'Get' implies a read-only operation, the description lacks critical details: error behavior when the ID doesn't exist, authentication requirements, rate limits, or what constitutes 'full details' given the absence of an output schema.

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

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

The description is a single, efficient sentence of nine words. It is front-loaded with the action verb and contains no redundant or filler text. Every word serves a purpose in defining the tool's function.

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

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

For a single-parameter retrieval tool, the description meets minimum viability. However, given the lack of an output schema or annotations, the description should ideally characterize the returned data structure or content types. As written, it leaves significant ambiguity about the response format.

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% ('The listing ID'), establishing a strong baseline. The description reinforces the parameter's role with 'by ID' but does not add semantic constraints (e.g., format, length, source from create_listing) or usage examples beyond what the schema already provides.

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 ('Get') and resource ('marketplace listing') and clarifies scope ('full details', 'by ID'). It implicitly distinguishes from sibling 'search_listings' by emphasizing 'specific' retrieval by ID rather than querying, though explicit differentiation would strengthen this.

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 no guidance on when to use this tool versus alternatives like 'search_listings' (for finding listings without an ID) or 'get_cart'/'get_order' (for different business objects). No prerequisites or conditions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies read-only access via 'Retrieve' but fails to disclose error handling (e.g., invalid ID), return value structure, caching behavior, or idempotency traits.

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?

Single sentence is efficiently structured with no redundant words. However, given the absence of annotations and output schema, the description may be overly terse rather than appropriately concise.

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?

Lacks output schema and annotations, yet the description fails to compensate by describing the return structure, field details, or error scenarios. The phrase 'detailed information' is vague and insufficient for an agent to predict the response shape.

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% (the 'id' parameter is fully documented as 'The generic Order ID'). The description adds no additional parameter semantics, meeting the baseline for high-coverage schemas.

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?

Uses specific verb 'Retrieve' with resource 'Order' and references standard 'TMF622', clearly indicating a read operation. However, it does not explicitly distinguish from sibling 'create_order' or other 'get_' tools in the description text.

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 no guidance on when to use this tool versus alternatives like 'create_order' or 'get_cart', nor does it mention prerequisites such as needing a valid Order ID from a previous operation.

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 provided, so description carries full burden. Discloses return structure, supported protocol versions, and critical auth requirement (UNISWAP_API_KEY). Implies read-only nature via 'Get' and quote semantics, though could explicitly state it does not execute transactions.

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, zero waste. Front-loaded with purpose, followed by returns, capabilities, and requirements. Every clause delivers distinct value (what, output, protocols, auth).

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?

Compensates well for missing output schema by detailing return values (estimated output, routing, gas, impact) and operational requirements. Lacks error handling or rate limit disclosure, which would elevate to 5 for a financial API tool.

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

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

Schema description coverage is 100%, providing complete parameter documentation (token symbols/addresses, human-readable amounts, defaults). Description does not add parameter-specific guidance beyond schema, earning 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?

Description opens with specific verb 'Get' and specific resource 'swap quote from Uniswap', clearly distinguishing it from e-commerce siblings like create_order or add_item. Unambiguous 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?

Implies usage context by detailing return values (output, routing, gas, impact) and supported protocols (V2-V4, UniswapX), but lacks explicit when-to-use guidance relative to sibling check_token_approval or which protocol version to select.

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 of behavioral disclosure. It successfully communicates the critical 10-minute expiry window and the pending payment state, but omits other important behavioral details such as failure modes, idempotency, or what happens when the hold expires.

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 three-sentence structure is optimally front-loaded: action definition first, critical constraint (10 minutes) second, scope clarification third. Every sentence conveys essential information with zero redundancy or filler text.

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 both output schema and annotations, the description adequately compensates by explaining the operational effect (temporary hold). However, it could be improved by describing the return value or success/failure indicators expected from this mutation operation.

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

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

The input schema has 100% description coverage, establishing a baseline of 3. The description implies the relationship between parameters ('pending payment' hints at cartId's purpose), but does not add syntax details, validation rules, or format constraints beyond what the schema already provides.

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 provides specific verbs (hold/reserve), identifies the exact resource (session time slot), and clarifies the beneficiary (customer). The phrase 'Works for any bookable service' effectively scopes the tool's applicability and distinguishes it from potentially service-specific booking tools.

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

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

The description provides clear temporal context ('held for 10 minutes pending payment') that implies the tool's position in a checkout workflow. However, it stops short of explicitly naming sibling alternatives like confirm_payment or stating exclusion conditions (e.g., 'do not use if slot already held').

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 provided, so description carries full burden. Mentions 'confirmed' state but doesn't explain booking lifecycle states, pagination behavior, or what happens when filters match nothing. Omits auth/permission requirements.

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 efficient sentences with zero waste. Front-loaded with primary action, followed by filtering capabilities.

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?

Adequate for a simple 2-parameter list operation without output schema, but lacks domain context (what defines a 'session' vs other bookable entities) and return value expectations.

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

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

Schema coverage is 100% with clear descriptions. The description confirms filters are optional ('Optionally'), matching the zero required parameters, but adds no syntax guidance beyond the schema's YYYY-MM-DD hint.

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?

Clear verb ('List') and resource ('confirmed session bookings'), with 'confirmed' usefully distinguishing from sibling 'get_available_slots'. However, it doesn't clarify relationship to 'hold_slot' or 'get_order' which may represent similar concepts in this domain.

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

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

No guidance on when to use versus siblings like 'hold_slot' (which likely precedes booking) or 'get_order'. No mention of prerequisites or filter selection strategy.

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 successfully discloses the authorization requirement (seller-only), but omits behavioral details like idempotency, side effects on associated orders/carts, return values, or reversibility of the deletion.

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

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

Two sentences, zero waste. The first states the action; the second states the critical authorization constraint. Both earn their place and are front-loaded with no filler text.

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

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

For a simple two-parameter deletion tool with 100% schema coverage, the description covers the essential business logic (auth) and action. It lacks return value documentation (compounded by no output schema), but adequately covers the operational contract for an AI agent to 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?

While the schema has 100% coverage documenting both listingId and sellerAddress, the description adds crucial business context: 'Only the seller can remove their own listing' reinforces the validation rule on sellerAddress ('must match listing'), adding semantic meaning beyond the schema's syntax description.

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

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

The description uses a specific verb ('Remove') with a clear resource ('marketplace listing'), immediately distinguishing it from sibling tools like get_listing (fetch) or create_listing (create). The scope is unambiguous.

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

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

The second sentence ('Only the seller can remove their own listing') provides explicit authorization constraints, effectively guiding when to use (you are the seller) and when not to use (you are not the seller). It lacks explicit naming of alternatives for non-sellers, but the permission boundary is clearly stated.

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

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

No annotations provided, so description carries full burden. Discloses return content ('active listings with prices and seller info') and state filtering ('active'). However, missing pagination behavior, sorting logic, or error conditions that would be expected for a search 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 well-structured sentences with zero waste. Front-loaded with action ('Browse'), followed by usage mechanics, then return value. 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?

Adequately compensates for missing output schema by describing return structure (prices, seller info). Given simple 3-parameter input and no nested objects, description covers essential context, though could note pagination or result ordering.

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%, establishing baseline 3. Description reinforces parameter meaning by categorizing them as search mechanisms and providing category examples, but doesn't add syntax details or validation rules 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?

Clear verb+resource ('Browse the W3Ship P2P marketplace', 'Search by category...'). Distinguishes from sibling 'get_listing' through plural 'listings' and search/filter semantics, though it doesn't explicitly name the sibling alternative.

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

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

Provides implied usage through parameter explanation ('Search by category... or keyword'), indicating when filters apply. However, lacks explicit when-to-use guidance versus 'get_listing' or other sibling tools like 'create_listing'.

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 security model ('securely', 'timed cryptographic signature') implying replay protection and authentication requirements, but omits failure modes, rate limits, or return value structure.

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?

Single, dense sentence of 11 words. Every word earns its place: action ('retrieve'), resource ('physical address'), and security mechanism ('public key', 'timed cryptographic signature') are all front-loaded with zero 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?

Adequate for invoking the tool given the well-documented schema, but incomplete regarding what the tool returns (no output schema exists) and error conditions (e.g., invalid signature behavior). Given the 'secure' nature, more behavioral context would strengthen this.

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%, establishing a baseline of 3. The description adds minimal semantic value beyond the schema—'timed' reinforces the timestamp-signature relationship already documented in the schema, but doesn't explain parameter formats or validation rules beyond 'hex-encoded'.

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

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

States a specific action ('retrieve') and resource ('physical address') clearly. The cryptographic mechanism distinguishes it implicitly from sibling getters like get_identity, though it doesn't explicitly differentiate from them.

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

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

Provides no guidance on when to use this tool versus alternatives (e.g., get_identity) or prerequisites for the cryptographic signature. The 'securely' qualifier hints at sensitive use cases but lacks explicit direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Track' implies a read operation, the description does not confirm it is read-only, describe the return format, mention error cases (e.g., invalid shipmentId), or disclose rate limits.

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

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

The description is a single, front-loaded sentence with minimal waste. However, the '(TMF621)' reference adds limited value for an AI agent without additional context about this standard.

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 simple string inputs and 100% schema coverage, the description is minimally adequate. However, given the lack of annotations and output schema, it should ideally describe the return value (tracking details) and confirm the read-only nature of the operation.

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

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

With 100% schema description coverage (both shipmentId and orderId are documented), the baseline score is 3. The description does not add semantic details beyond the schema (e.g., ID format examples or lookup semantics), but the schema already adequately defines the 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 clearly states the specific action (Track), resource (shipment), and scope (delivery status). However, it does not explicitly distinguish from sibling tools like `add_tracking` (which likely adds tracking data rather than querying it) or `get_order` (which may also return status information).

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 no guidance on when to use this tool versus alternatives such as `get_order` or `add_tracking`, nor does it mention prerequisites like requiring a valid shipmentId or when to use the optional orderId parameter instead.

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