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

No annotations provided, so description carries full burden of disclosure. Fails to indicate whether the operation is persistent (saves to user profile), idempotent, validates the address against DoorDash's service area, or returns the created address ID.

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 redundancy and clear front-loading. However, extreme brevity contributes to under-specification for a 7-parameter mutation tool.

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

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

Inadequate for a complex mutation operation with 7 parameters and no annotations. Lacks explanation of output behavior, error conditions (e.g., invalid address), and relationship to sibling address management tools.

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

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

Schema description coverage is 100%, so baseline applies. Description adds no parameter semantics beyond the schema (e.g., doesn't explain that lat/lng are required for geocoding or that google_place_id is optional for validation).

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 the basic action ('Add') and resource ('delivery address'), but fails to distinguish from sibling 'doordash_set_address'. Does not clarify whether this creates a persistent saved address or adds to a temporary session, leaving scope ambiguous.

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

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

Provides no guidance on when to use this tool versus 'doordash_set_address' or 'doordash_addresses'. Missing prerequisites such as authentication requirements or when address validation occurs.

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 must carry full behavioral disclosure burden. While 'Add' implies mutation, the description omits security implications of handling sensitive card data, validation behavior, idempotency concerns, or error scenarios (e.g., invalid card numbers).

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 a single six-word sentence that is front-loaded and contains no redundancy. However, it may be excessively brief given the sensitive nature of the operation.

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

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

Despite complete parameter schema coverage, the tool handles sensitive financial data with no output schema or annotations. The description fails to compensate by explaining success indicators, error handling, security considerations, or prerequisites, leaving significant gaps for an agent attempting to invoke this safely.

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 all four parameters (card_number, exp_month, exp_year, cvc). Since the schema fully documents the parameters, the description baseline is appropriate without additional parameter details.

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 the specific action ('Add') and resource ('payment card') with the target system ('DoorDash'). However, it does not differentiate from sibling tool 'doordash_payment_methods', which likely retrieves cards rather than adding them.

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites such as requiring an active login session, or whether this should be called before 'doordash_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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'List' implies a read-only operation, the description fails to confirm safety traits, disclose return format (array of address objects), mention authentication requirements, or note whether the default address is marked specially.

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 extremely brief at only four words, containing no wasted text. However, it is so terse that it borders on under-specification rather than optimal conciseness, lacking a period or complete sentence structure that would formally signal the end of the description.

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 low complexity (zero parameters, no nested objects) and lack of output schema, the description is minimally adequate but incomplete. It fails to hint at the return structure or explain what constitutes a 'saved' address versus other address types in the DoorDash 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?

The tool has zero parameters and the input schema is an empty object. Per the rubric, 0 parameters establishes a baseline of 4, as there are no parameter semantics to elaborate upon beyond what the schema already conveys.

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

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

The description uses a specific verb 'List' and identifies the resource as 'saved delivery addresses', distinguishing it from sibling tools like doordash_add_address (which adds) and doordash_set_address (which likely sets active). However, it lacks explicit scope clarification (e.g., 'for the authenticated user') that would make it a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like doordash_set_address or doordash_add_address. It does not mention prerequisites (e.g., requiring authentication) or typical use cases (e.g., 'use before placing an order to view available addresses').

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 burden but only discloses the basic operation. It fails to explain cart creation behavior (cart_id is optional in schema), group order workflows, idempotency, or error conditions.

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 two-sentence structure is perfectly efficient—first stating purpose, second providing the critical restaurant/convenience store distinction. No redundancy or filler content.

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

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

For an 8-parameter tool with complex JSON options structures and group order support (external_user_id), the description covers the store-type dichotomy but omits group order usage patterns and cart lifecycle management details.

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?

Despite 100% schema coverage, the description adds crucial semantic context about the mutually exclusive usage patterns for item_name vs item_id based on store type. This conditional logic is not obvious from the schema alone.

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 core action ('Add an item') and resource ('DoorDash cart'). It adds domain-specific context distinguishing restaurant vs convenience store flows, though it doesn't explicitly differentiate from sibling tools like 'doordash_modify_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 provides conditional parameter guidance (item_name for restaurants, item_id for convenience stores), which helps with correct invocation. However, it lacks guidance on when to use this tool versus 'doordash_modify_cart' or prerequisites like requiring an active cart session.

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. 'View' implies read-only safety and 'contents and totals' hints at return data, but it omits authentication requirements, empty cart behavior, and return format 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?

Single sentence of 7 words with zero redundancy. Purpose is front-loaded immediately with no filler content.

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

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

For a simple read operation, it adequately describes the functional scope, but given the lack of output schema, it should specify the return format (e.g., item list, pricing breakdown) or error conditions.

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 0 parameters, establishing baseline 4. The description appropriately does not fabricate parameter details, though it could explicitly confirm no filters are available.

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 verb 'View' with clear resource 'DoorDash cart contents and totals', effectively distinguishing this read operation from sibling write operations like doordash_add_to_cart, doordash_modify_cart, and doordash_delete_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?

While the read-only nature is implied by 'View', the description lacks explicit guidance on when to use this tool (e.g., 'check before checkout') or when to prefer doordash_modify_cart instead.

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 and successfully communicates that this is a safe, non-destructive preview operation rather than a transaction. It does not disclose additional behavioral traits such as idempotency, validation behavior, or specific error conditions, but covers the critical safety constraint.

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 efficient sentences with the primary action front-loaded in the first sentence and the critical safety constraint in the second. There is no redundant or wasteful 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 tool's low complexity (single optional parameter) and lack of output schema, the description adequately covers the return value implicitly by mentioning 'fees, total' and sufficiently distinguishes the tool's role from its siblings. It appropriately addresses the tool's specific purpose without unnecessary elaboration.

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 single `cart_id` parameter, establishing a baseline score. The description text adds no additional parameter semantics 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 a specific verb (preview) and resource (checkout details) with explicit scope (fees, total). The phrase 'Does NOT place the order' clearly distinguishes this tool from its sibling `doordash_place_order`, preventing incorrect agent selection.

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 negative guidance stating the tool 'Does NOT place the order,' which implicitly contrasts with `doordash_place_order` and prevents misuse. However, it does not explicitly state the positive use case (e.g., 'use this to review costs before placing an order') or name the alternative tool directly.

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 but only defines the domain scope (convenience store types). It fails to mention return format, pagination behavior, error cases (e.g., invalid store_id), or 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?

Single sentence, front-loaded with the action verb, and no redundant words. However, extreme brevity leaves gaps in behavioral disclosure that could have been addressed without sacrificing clarity.

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 simple 2-parameter input schema and lack of output schema, the description meets minimum viability by establishing the tool's domain. However, it should ideally hint at return values or the prerequisite workflow given zero annotation coverage.

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

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

Schema description coverage is 100% (both store_id and query are fully documented in the schema with examples). The description adds no parameter-specific guidance, which aligns with the baseline score for high 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 uses specific verb 'Search' and resource 'items within a convenience store', clearly distinguishing from the general 'doordash_search' sibling by specifying the convenience retail domain (grocery, alcohol, pharmacy). However, it doesn't explicitly contrast with restaurant/menu search 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?

No guidance provided on when to use this versus the general 'doordash_search' tool, nor does it mention that 'store_id' must be obtained beforehand (likely via the general search). No prerequisites or alternatives are documented.

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 it mentions the share link return value (helpful given no output schema), it omits critical side effects: whether this initializes an empty cart, if there's an expiration timer, authentication requirements, or that participants must use the link to join before checkout.

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

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

Extremely concise at two sentences with no redundancy. However, given the lack of annotations and output schema, the brevity borders on under-specification rather than efficient communication, warranting a slight deduction.

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 group ordering workflow (moderately complex domain), the description is insufficient. It fails to explain the group order lifecycle, how invitees interact with the share link, or the relationship to cart/checkout tools. The mention of 'share link' partially compensates for missing output schema but leaves operational context gaps.

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 single 'store_id' parameter. The description adds no additional semantic context (e.g., format examples, how to obtain the ID), 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?

The description clearly states the action ('Create') and resource ('group order'), distinguishing it from regular orders via the sibling tool 'doordash_place_order'. The mention of returning a 'share link' clarifies the collaborative output nature, though it doesn't explicitly contrast with 'doordash_join_group_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?

No explicit guidance on when to use this versus placing a regular order or joining an existing group order. The description implies it's for creating new collaborative sessions but doesn't state prerequisites (e.g., needing to add items afterward) or workflow sequencing.

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 but offers minimal detail. It states the action is 'Delete' but omits critical context such as whether the deletion is permanent, irreversible, or has cascading effects on active orders.

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 appropriately brief at three words, but it is front-loaded with minimal value. While not verbose, it represents under-specification rather than efficient conciseness given the destructive nature of the operation.

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

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

For a destructive operation on a single resource with no output schema, the description is inadequate. It lacks warnings about irreversibility, side effects on associated data (e.g., saved items), or success/failure indicators that would help the agent handle the response.

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% (cart_id is fully documented), establishing baseline 3. The description adds no additional semantic context about the parameter (e.g., format expectations, where to obtain the ID), but none is required given the schema completeness.

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 'Delete a cart' is tautological, merely restating the tool name without adding specificity. It fails to distinguish this tool from sibling cart operations like doordash_modify_cart (which removes items) or clarify the scope of 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?

No guidance provided on when to use this versus alternatives (e.g., using modify_cart to remove specific items instead of deleting the entire cart), nor any prerequisites such as cart state requirements.

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 full disclosure burden. It indicates a read operation via 'View' and adds valuable context about the output structure ('broken down by person'), but lacks critical behavioral details like error handling for invalid cart_id, authentication requirements, or whether the breakdown includes pricing per person.

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 single sentence is appropriately front-loaded with the action verb, contains zero redundancy, and efficiently communicates the core value proposition without filler words. Length is optimal for the tool's simplicity.

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 (single string parameter, 100% schema coverage) and lack of output schema, the description adequately explains the return value concept (items by person). It meets minimum viability but could enhance completeness by mentioning the typical flow (use after create/join group order).

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 ('Group cart ID'), the schema fully documents the parameter. The description implies the cart_id refers to a group order but adds no semantic detail beyond what the schema already provides, 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?

The description uses specific verb 'View' with clear resource 'group order's items' and adds distinguishing detail 'broken down by person' that differentiates it from sibling tools like doordash_order_status (general status) and doordash_cart (simple item list). However, it could explicitly clarify the distinction from regular order status.

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

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

No explicit when-to-use guidance or alternatives are mentioned. While 'group order' implies usage for group orders specifically, the description fails to specify when to use this versus doordash_order_status or doordash_cart, or prerequisites like requiring an active group 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?

No annotations provided, so description carries full burden. While 'Get' implies read-only access, the description lacks explicit behavioral details such as error handling, rate limits, or whether results are cacheable.

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 efficient sentence with zero waste. Parenthetical examples are high-value and immediately clarify the abstract term 'customization options'. Perfectly 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?

Adequate for a simple two-parameter retrieval tool, but misses opportunity to clarify workflow integration (e.g., that this should be called between doordash_menu and doordash_add_to_cart). No output schema exists to document.

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% (both store_id and item_id fully described in schema). The description adds no parameter-specific semantics beyond the schema, 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?

States a specific action ('Get') and resource ('customization options for a menu item') with concrete examples (sides, extras, modifications). Clear distinction from doordash_menu is implied but not 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?

Lacks explicit when-to-use guidance or named alternatives. Usage sequence is only implied by the resource type (needing a menu item first), but the description text does not state prerequisites or workflow position relative to siblings like doordash_add_to_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?

No annotations provided, so description carries full burden. It discloses the creation of a 'guest session' and its purpose, but omits session lifecycle (expiration), idempotency, error conditions if cart is closed/full, or whether this overwrites existing guest sessions.

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 highly efficient sentences. First establishes purpose and actor, second establishes the output/relationship to next step. No filler words, front-loaded with action, 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?

Adequate for workflow understanding but incomplete given no output schema exists. Mentions session creation but doesn't describe the return structure (session ID format) or failure modes (invalid cart_id, closed orders). Given 5 required params and mutation behavior, needs richer behavioral disclosure.

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 for all 5 parameters. Description adds minimal semantic value beyond the schema but provides the 'guest' context that explains why first_name/last_name are required. Baseline 3 appropriate when schema is comprehensive.

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 clarity with specific verb 'Join', resource 'group order', role 'as a guest', and context 'on behalf of another user'. Clearly distinguishes from sibling 'doordash_create_group_order' (which creates) and 'doordash_add_to_cart' (which consumes the session).

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 names the workflow continuation: 'can be used with doordash_add_to_cart', establishing the correct sequence. However, lacks explicit 'when not to use' guidance or prerequisites (e.g., requiring an active group order cart_id).

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 effectively reveals critical behavioral traits: credentials are read from ~/.doordash-mcp/config.json (external dependency) and the tool exhibits dual-mode behavior returning either success or an MFA challenge. It misses session persistence details but covers the essential auth flow.

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

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

Three short sentences with zero waste: action declaration, credential source disclosure, and return value specification. Information is front-loaded with the core purpose, and each subsequent sentence adds essential behavioral context not available in structured fields.

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

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

For a zero-parameter authentication tool without output schema, the description adequately covers the essential contract: credential source, success path, and MFA challenge path. It could improve by mentioning session prerequisites for sibling tools, but the return behavior disclosure provides sufficient context for invocation.

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

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

With zero parameters, the baseline score applies per rubric guidelines. The empty input schema requires no additional semantic clarification, and the description correctly implies no user input is needed at call time (credentials come from config file).

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 the specific action 'Log into DoorDash', clearly identifying both the verb (log into) and resource (DoorDash). It effectively distinguishes itself from sibling operational tools like doordash_search or doordash_checkout by being the sole authentication entry point.

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?

While the tool's position as the only 'login' tool among operational siblings implies it should be used first, the description lacks explicit guidance on when to invoke it (e.g., 'call before other tools') or when not to (e.g., 'skip if already authenticated'). Usage is implied by context but not stated.

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

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

No annotations are provided, placing full disclosure burden on the description. While 'Get' implies a read-only operation, the description lacks details on return format (menu structure), error handling for invalid store IDs, or rate limiting. It meets minimum behavioral disclosure for a simple getter.

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 redundancy: first establishes purpose, second provides workflow prerequisite. Information is front-loaded and every word serves a specific function for agent decision-making.

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 low complexity (single required parameter) and lack of output schema, the description adequately covers the essential workflow context. Could be improved by describing the menu data structure returned, but sufficient for agent selection and invocation.

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

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

With 100% schema description coverage ('DoorDash store ID (numeric)'), the schema carries the semantic load. The description references 'store ID' aligning with the parameter name but adds no additional format guidance, constraints, or examples beyond the schema definition.

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 (Get), resource (restaurant's menu), and required input mechanism (by store ID). It effectively distinguishes this retrieval tool from sibling ordering and search tools by specifying the exact workflow entry point.

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 prescribes the correct sequencing by naming the prerequisite tool: 'Use doordash_search first to find the store ID.' This provides clear when-to-use guidance and establishes the dependency relationship with doordash_search.

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 adequately discloses the mutation behavior (modifying quantities, removing items) but omits other behavioral traits such as side effects (price recalculation), idempotency, or the group order context implied by the external_user_id parameter.

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 extremely concise with zero redundant words. However, given the tool's complexity (6 parameters, mutation behavior, group order support) and lack of annotations, it verges on being overly terse rather than appropriately informative.

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

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

Given the well-documented schema covering all parameters, the description meets minimum viability. However, for a mutation tool with no output schema and no annotations, it has clear gaps—particularly regarding behavioral details, error conditions, and the group order functionality supported by the external_user_id parameter.

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

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

The input schema has 100% description coverage, establishing a baseline score of 3. The description maps generally to the action enum values ('change quantity' = update_quantity, 'remove' = remove) but does not add semantic meaning beyond the schema, such as explaining that quantity is conditional on action or detailing the group order use case.

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 modifies carts by changing item quantity or removing items, using specific verbs and resources. It implicitly distinguishes from siblings like doordash_add_to_cart (adding new items) and doordash_delete_cart (deleting the entire cart) by specifying item-level operations, though it could explicitly contrast with these alternatives.

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

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

The description implies usage through the specific actions mentioned ('change item quantity or remove'), suggesting when to use this tool versus adding items. However, it lacks explicit guidance on when to use this versus doordash_delete_cart or prerequisites like requiring an existing cart_id from doordash_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 provided, the description carries full burden but fails to define 'recent' (time window), mention authentication requirements, or describe error behavior when no orders exist. It implies a read-only operation but lacks explicit behavioral 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?

Extremely concise at only five words. Every word earns its place: 'Get' (action), 'recent' (scope), 'DoorDash' (domain), 'order history' (resource). No redundancy or 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 single-parameter read operation, the description is minimally viable. However, given the lack of annotations and output schema, it should ideally specify the time window for 'recent' orders and clarify the return structure.

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 does not mention the 'limit' parameter, but the schema fully documents it including the default value of 5. The description adds no supplementary semantics about parameter usage.

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 ('DoorDash order history'), and adds the scope 'recent' which clarifies this retrieves historical data rather than active orders. However, it does not explicitly distinguish from sibling tool 'doordash_order_status' which likely checks specific order states.

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 'doordash_order_status' or prerequisites like authentication (despite 'doordash_login' existing in siblings). No mention of when not to use or alternatives for fetching older orders.

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 does not specify what status information is returned (e.g., preparation stage, delivery ETA), whether the operation is idempotent, or if there are rate limits. The verb 'Check' implies read-only but does not confirm safety 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 a single, efficient sentence with no wasted words. However, given the lack of annotations and output schema, it may be overly terse—slightly more detail on return value or distinguishing scope would add value without sacrificing clarity.

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

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

For a simple single-parameter tool, the description is minimally viable. However, without an output schema, it should ideally hint at what status details are returned (e.g., 'preparing', 'delivered') to set caller expectations, which it does not.

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 ('Order UUID from doordash_place_order'), the schema fully documents the single parameter. The description adds no additional semantic context about the parameter, 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?

The description uses a specific verb ('Check') and resource ('status of a DoorDash order'), clearly indicating a read operation on order state. However, it does not explicitly differentiate from sibling tools like 'doordash_orders' (likely a list operation) or 'doordash_group_order_status'.

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 text provides no guidance on when to use this tool versus alternatives (e.g., 'doordash_orders' for listing history). While the input schema notes the order_id comes from 'doordash_place_order', the description itself lacks explicit when/when-not instructions.

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. The verb 'List' implies a read-only operation, but the description fails to disclose what data structure is returned, whether payment details are masked, or if authentication is required to access sensitive payment data.

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 words with zero redundancy. Every word earns its place: 'List' specifies the operation, 'saved' distinguishes from temporary methods, and 'payment methods' identifies the resource.

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

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

For a zero-parameter list operation, the description meets minimum viability but has clear gaps. Given the sensitivity of payment data, the description should mention return format (e.g., masked card numbers) or authentication requirements. Without an output schema, the description should compensate by describing what gets returned.

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 contains zero parameters. According to the scoring rubric, zero parameters establishes a baseline score of 4, as there are no parameter semantics to clarify beyond what the empty schema already indicates.

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

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

The description clearly states the verb (List) and resource (saved payment methods). While it doesn't explicitly name sibling tools like 'doordash_add_card', the verb choice effectively distinguishes this as a read operation versus the add/modify siblings.

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 tool versus alternatives like 'doordash_add_card' or 'doordash_checkout'. No mention of prerequisites such as requiring authentication before listing payment methods.

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 behavioral burden. The explicit financial impact warning ('THIS WILL CHARGE YOUR CARD') is critical transparency for a destructive operation, though it omits other behavioral details like idempotency, cart state changes, or error scenarios.

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: the first establishes purpose, the second provides essential financial risk disclosure. Perfectly front-loaded with every word earning 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 4-parameter financial transaction tool with no output schema, the description covers the critical 'charging' aspect but lacks operational context such as return values, success/failure behaviors, or order confirmation details.

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 (cart_id, tip_cents, etc.), establishing a baseline of 3. The description adds no parameter-specific semantics beyond the schema, such as explaining the relationship between cart_id and the checkout workflow.

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 ('Place') and resource ('DoorDash order'), distinguishing it from sibling tools like doordash_checkout or doordash_add_to_cart by indicating this is the final transaction 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?

While the uppercase warning 'THIS WILL CHARGE YOUR CARD' implicitly signals this is the terminal payment step, the description lacks explicit guidance on prerequisites (e.g., 'use after doordash_checkout') or when to use alternatives like group orders.

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 full disclosure burden. It fails to indicate whether authentication is required, whether the operation is read-only, what the return format contains (restaurant objects, IDs, etc.), or any rate limiting. Only the basic search intent is disclosed.

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 of nine words with zero redundancy. Every word earns its place by conveying the action, platform, resource, and search dimensions.

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 search tool without output schema, the description is minimally adequate. However, given the complex DoorDash ecosystem (evident from 20+ sibling tools), it lacks prerequisite context (e.g., whether address/login must be set first) or hints about the return structure.

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 coverage, the baseline is 3. The description adds value by categorizing the query parameter's purpose into three semantic buckets (name, cuisine, or food type), which helps the agent understand valid query patterns beyond the schema's generic examples.

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

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

The description clearly states the verb 'Search' and resource 'restaurants on DoorDash', and specifies searchable attributes (name, cuisine, food type). It implicitly distinguishes from the sibling 'doordash_convenience_search' by specifying 'restaurants', though it doesn't explicitly name the sibling.

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 by specifying the tool searches for 'restaurants' (suggesting use when seeking food establishments) and lists valid query types (name, cuisine, food type). However, it lacks explicit guidance on when NOT to use it or direct comparison to doordash_convenience_search.

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 a state mutation ('Set'), but fails to disclose persistence scope (session vs. account), side effects (impact on active cart/checkout flow), error conditions (invalid address_id), 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?

The description is extremely brief (4 words) and front-loaded with the verb. However, given the lack of annotations and the tool's mutating nature, this brevity results in under-specification rather than appropriate conciseness—critical behavioral context is omitted.

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 mutation tool with 100% schema coverage, the description provides the minimal viable context. However, gaps remain regarding the 'active' address lifecycle, relationship to checkout workflows, and error handling. Without annotations or an output schema, the description should have elaborated on behavioral implications.

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 address_id parameter is fully described in the schema as 'Address ID from doordash_addresses'). The description provides no additional parameter semantics, syntax details, or examples beyond what the schema already documents, warranting the baseline score.

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 ('Set') and resource ('active delivery address'), clearly distinguishing from sibling 'doordash_add_address' (which creates addresses) by implying selection of an existing address. However, it could explicitly clarify that this selects from previously saved addresses rather than creating new ones.

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

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

No explicit when-to-use guidance or prerequisites are provided. While the parameter description references 'doordash_addresses' (implying it should be called after fetching addresses), there is no explicit guidance on workflow ordering, authentication requirements, or when to use this versus 'doordash_add_address'.

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 must carry the full burden of behavioral disclosure. It mentions completing login but fails to explain critical behavioral traits: whether this establishes a persistent session, modifies authentication state, or has idempotency concerns. The agent cannot determine side effects from the description alone.

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 single-sentence description is efficiently structured and front-loaded with the action verb. However, given the complete absence of annotations and output schema, the extreme brevity leaves significant gaps in agent guidance that a slightly longer description could address.

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 tool with full schema coverage, the description is minimally adequate. However, given no output schema exists and this is part of a multi-step authentication flow (evidenced by sibling doordash_login), the description should ideally clarify the prerequisite step or success/failure outcomes to be 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?

With 100% schema description coverage, the input schema already fully documents the 'code' parameter as a '6-digit verification code'. The description mentions 'verification code' but adds no additional semantic context (e.g., where the code comes from, expiration constraints) beyond the schema, meriting the baseline score.

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 (complete login) and resource (DoorDash) using a distinct mechanism (verification code), which implicitly distinguishes it from the sibling 'doordash_login' tool. However, it doesn't explicitly clarify the two-step workflow relationship.

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?

While the phrase 'Complete DoorDash login' implies this is a secondary step requiring a verification code, there is no explicit guidance on when to use this versus doordash_login, nor does it state the prerequisite of initiating login first or what happens if called without a pending verification.

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