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

With no annotations, the description fully discloses key behaviors: resolves names to codes, auto-fills required choices, computes price, rejects out-of-stock items, appends to basket, returns catalog on unknown names, and dry_run does not save. This is comprehensive for a mutation 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?

The description is a dense paragraph but every sentence provides useful information. It is front-loaded with the main action and then details behaviors and parameters. It could be slightly more structured with bullets, but it remains concise and to the point.

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

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

The description covers the main workflow, failure case, language handling, and dry_run mode. However, since there is no output schema, it does not explicitly state what a successful add returns (e.g., updated cart or confirmation), which is a minor gap. Overall, it is sufficiently complete for a complex mutation tool.

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

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

Schema coverage is 100%, but the description adds significant value beyond the schema. It explains the `options` parameter with an example, clarifies that names or codes are accepted, and describes `lang` default behavior and `dry_run` semantics, which are 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 'Add a menu item to the shop's server-side basket' with a specific verb and resource. It also distinguishes from siblings by emphasizing the plain-language option resolution and no price math, making it specific to this 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 description implies when to use it (adding an item to the basket) and provides operational guidance like using plain-language names and dry_run for preview. It does not explicitly contrast with sibling tools, but the context is clear enough for an agent to select it correctly.

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

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

With no annotations given, the description carries the full burden. It covers destructive action (delete), server-side scope, non-effect on placed orders, and authentication. Missing details like irreversibility or empty-basket behavior, but still substantive.

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, each adding essential information: the operation, the exclusion of order cancellation, and the auth requirement. 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 simple one-parameter destructive tool, the description covers the main contextual aspects: scope, side effects, and prerequisites. It omits response behavior or edge cases, but these are less critical given no output schema and the tool's simplicity.

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

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

The schema fully describes restaurant_id with 100% coverage, and the description adds no further parameter-specific meaning. This matches the baseline of 3 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 clearly states a specific action (delete) and resource (server-side basket entirely), distinguishing it from siblings like remove_item that target individual items. The phrase 'removes it from the efood app' reinforces the full-scope 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?

It provides a clear exclusion ('does not cancel any placed order') and notes the authentication prerequisite, which informs when to use the tool. However, it does not explicitly name alternatives for order cancellation, leaving room for improvement.

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

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

With no annotations provided, the description carries the full burden. It discloses that authentication is required and implies a read-only operation via 'List'. The note about the address id being necessary for orders gives insight into return semantics. While it doesn't cover every edge case (e.g., empty results), it is sufficient for a simple read 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?

Two sentences, front-loaded with the core purpose, and every sentence adds value. The first sentence states the action, the second provides critical usage context and auth requirement. No wasted words.

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

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

For a zero-parameter, read-only tool with no output schema, the description covers the essential context: what it lists, why it matters (address id for orders), and authentication. It does not explicitly describe the return structure, but the address id hint provides adequate completeness for this simple tool.

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

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

The input schema has zero parameters, so the description does not need to explain parameter semantics. Per the rubric, 0 parameters yields a baseline of 4. The description appropriately focuses on the output rather than inputs, making it fully adequate.

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

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

The description uses a specific verb and resource: 'List the delivery addresses saved on your efood account.' This clearly states what the tool does and distinguishes it from sibling tools like place_order or get_payment_methods, as no other tool handles saved addresses.

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

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

The description provides clear context on when to use the tool: 'The id of an address is required to validate or place an order.' This implies the tool is used to retrieve address IDs for subsequent order operations. However, it does not explicitly mention alternatives or when not to use it, so it stops short of a 5.

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

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

The description discloses that this is a read operation ('Read'), which implies non-destructive behavior, and details the returned data (line items with names, options, quantities, prices, total). It adds the index information but does not address error cases or authentication requirements, which are undisclosed but acceptable given no annotations.

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

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

The description is two sentences, front-loaded with the main purpose and then supporting details. No unnecessary words.

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

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

For a read tool with no output schema, the description adequately describes the return shape (line items with attributes and total) and notes the index field for remove_item. It does not mention error scenarios, but given the simplicity, it is fairly complete.

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

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

Schema coverage is 100%, so both lang and restaurant_id are described in the schema. The description does not add parameter specifics, just references 'shop' which corresponds to restaurant_id, but the baseline of 3 applies since schema covers 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 tool reads the current server-side basket, specifying the resource (basket) and the action (read). It distinguishes from siblings like clear_cart and remove_item by focusing on read-only access.

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

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

The description implies usage when you need to view the basket contents, mentioning that line items have an index used for remove_item, which hints at the read-then-modify workflow. However, it does not explicitly name alternative tools or state when not to use it, so it is clear but lacks explicit exclusions.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully states that no login is required and the verb 'Fetch' implies a read-only operation, disclosing the auth requirement. However, it lacks details on error scenarios, response format, or rate limits, which would be valuable without annotations.

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

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

The description consists of two sentences: the first states the core purpose, and the second adds usage context and auth requirement. It is well-structured, front-loaded, and free of unnecessary words.

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

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

For a simple fetch tool with three parameters and no output schema, the description covers the primary purpose, trigger condition, and auth requirement. It does not describe the response structure, but given the tool's simplicity and the absence of an output schema, this is a minor gap rather than a critical omission.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds domain context (e.g., single menu item, has_options) but does not add syntax-level meaning beyond what the schema provides, aligning with the baseline for full schema coverage.

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

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

The description clearly states the verb 'Fetch' and the resource 'customization/variation options for a single menu item', which distinguishes it from sibling tools like get_restaurant_menu that return a full menu. It also references the `has_options` flag, providing concrete context for when this tool applies.

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

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

The description explicitly states it is needed to build a valid cart line for items where `has_options` is true, giving a clear trigger condition. It does not explicitly name alternative tools or exclusion cases, but the context provides sufficient guidance on when to invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool lists orders, returns them 'most recent first', includes specific fields, optionally filters, and requires authentication. This covers the key behavioral traits (ordering, read-only nature implied by 'list', authentication) and adds value beyond a minimal description. It doesn't disclose rate limits or error behaviors, but for a simple read operation this is sufficient.

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

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

The description is three sentences, front-loaded with the main action and output details. Every sentence contributes: the first lists the tool's core function and return fields, the second adds an optional filter use case, and the third notes the authentication requirement. No wasted words, perfectly sized.

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

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

Despite having no output schema, the description enumerates the exact fields returned (restaurant, date, total, payment method, status, items). It also conveys ordering, filtering, and authentication. For a list tool with only two optional parameters and no output schema, this fully covers what an agent needs to know to invoke it correctly and interpret results.

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 'limit' and 'restaurant_id' have schema descriptions. The tool description adds a contextual note about restaurant_id being useful for 're-ordering the usual', but does not add meaning beyond the schema. The baseline of 3 is appropriate since the schema already documents the parameters fully and the description's extra note is marginal.

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 ('List your previous efood orders') and the specific resource (previous orders) with details on what each entry includes (restaurant, date, total, payment method, status, items). This differentiates it from siblings like get_order_status, which focuses on a single order, and search_restaurants, which is about finding restaurants. The verb+resource is explicit and unambiguous.

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

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

The description provides a clear use case: 'useful for re-ordering the usual' when filtering by restaurant. This implies when the tool is appropriate, and the optional restaurant filter adds context for a specific scenario. However, it does not explicitly name alternatives or state when not to use this tool (e.g., for live order tracking), so it lacks an explicit exclusion, keeping it from a 5.

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

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

With no annotations, the description carries the full burden. It mentions that authentication is required and uses the verb 'retrieve' to indicate a read-only operation. However, it does not disclose behavior for missing orders, error responses, or side effects, and the return format is not described.

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, well-structured sentence that front-loads the core purpose and includes the important authentication constraint. There is no wasted wording or redundant detail.

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

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

The tool is simple with one parameter, but the lack of an output schema means the description should specify what the return value contains. While 'current status' implies the output, it does not explain whether it is a simple string, an object, or how errors are reported. This leaves some ambiguity.

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

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

Schema coverage is 100%: the order_id parameter has a clear description stating it is returned by place_order. The tool description adds no additional parameter semantics, so it meets the baseline but does not exceed it.

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

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

The description clearly states the tool retrieves the current status of an existing order by its id, using a specific verb and resource. This distinguishes it from sibling tools like get_order_history, which likely serve a different purpose. The input requirement (order id) is also 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?

The description implies usage when an order id is available and current status is needed, but it does not explicitly state when to use this tool vs alternatives like get_order_history. No exclusions or alternative tool recommendations are provided, though the authentication requirement gives some usage context.

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

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

With no annotations, the description effectively discloses key behavioral traits: read-only operation, no exposure of full card numbers, and authentication requirement. This goes beyond a simple 'list' and addresses security and side-effect concerns.

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

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

The description is three sentences, each serving a distinct purpose: listing, usage, and safety/authentication. There is no redundancy or filler, making it highly concise and well-structured.

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

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

Despite no output schema or annotations, the description covers the essential context: purpose, usage with a sibling, read-only nature, security, and authentication. It doesn't mention pagination or empty-list behavior, but for a simple list tool, this is adequate.

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?

There are zero parameters, so the empty schema provides no information. The description adds meaning by explaining that payment methods are 'opaque tokens' and that a returned token is used with place_order, which helps the agent understand the data's purpose beyond schema.

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

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

The description clearly states the tool's action ('List the payment methods saved on your efood account') with a specific verb and resource, and distinguishes it from siblings like get_addresses by focusing on payment methods and tokens.

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 integration guidance ('Use a returned payment token with place_order'), which implies the tool's role in the checkout flow. It lacks explicit exclusions of alternatives, but the context is clear enough for an agent to know when to invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that no login is required and that the response includes menu, hours, offers, and discounts, which adds context beyond the schema. However, it lacks information on error behavior, rate limits, or handling of invalid restaurant IDs, leaving gaps in behavioral transparency.

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

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

The description is two concise sentences, front-loaded with the primary purpose and followed by a single critical usage note. Every word contributes value; there is no repetition 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?

Given the tool has 5 parameters but no output schema, the description partially compensates by stating what is returned (categories, items, prices, hours, offers, discounts). It covers the core functionality and prerequisites, though it could add a note about response structure (e.g., presence of nested objects) or error cases. Overall, it is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so all parameter meanings are already documented in the input schema. The description adds only one piece of contextual value: that restaurant_id comes from search_restaurants. This does not meaningfully enhance parameter understanding beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states a specific action ('Fetch a restaurant's full menu') with a defined resource (categories, items, prices) and additional data (opening hours, offers, discounts). This distinguishes it from sibling tools like search_restaurants (search for restaurants) and get_menu_item_options (item-specific options), making its purpose unambiguous.

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

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

The description provides explicit context on when to use this tool: after obtaining a restaurant `id` from search_restaurants. It also clarifies a key prerequisite (no login required). However, it does not explicitly state when NOT to use this tool or mention alternatives (e.g., get_menu_item_options for item-level details), so it falls short of a 5.

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

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

The description discloses critical behavioral traits beyond the destructiveHint annotation: it charges the chosen payment method, cannot be undone, performs validation against the delivery address, returns a summary, and requires explicit user approval before confirming. This adds substantial context about side effects and safety 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?

The description is dense but extremely well-structured: it front-loads the main purpose and consequence, then provides a clear 'Safety:' callout with the two-step flow, and ends with a practical payment note. No filler words; every sentence adds value.

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

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

Given the tool's complexity (destructive, no output schema, 6 parameters), the description fully covers the decision-relevant aspects: what it does, consequences, safety confirmation flow, payment options, and validation behavior. It also references related tools for prerequisites, making it complete for an agent to use correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining the two-phase confirm behavior (preview vs actual submit) and the payment limitation (no card entry, must use cash or saved token). It also references get_payment_methods, which is helpful for understanding the payment_token parameter.

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 this tool submits the shop's server-side basket as a real order, with the explicit consequence of charging the user's payment method and being irreversible. It uses a specific verb ('Submit') and identifies the resource (server-side basket → efood order), clearly distinguishing it from siblings like clear_cart or get_cart.

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

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

Explicitly instructs to call with confirm:false first to preview/validate, and only call confirm:true after user approval. Also provides an exclusion: card details cannot be entered here, pointing to get_payment_methods for payment tokens. This gives clear when-to-use and when-not-to-use guidance.

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

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

No annotations, so description carries burden. It discloses that authentication is required and that removing the last line clears the basket—a meaningful side effect. Could add more about response or reversibility, but the key behavioral traits are covered.

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

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

Three concise sentences: first states action and key parameter, second notes a critical side effect, third states auth requirement. No fluff, front-loaded, every sentence earns its place.

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

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

For a simple 2-parameter mutation tool with no output schema, the description covers purpose, parameter source, side effect, and authentication. It is sufficiently complete for an agent to invoke it correctly.

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

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

Schema already fully describes both parameters (index from get_cart, restaurant_id). The description adds little beyond the schema, mainly reinforcing that index comes from get_cart. Baseline 3 is appropriate given 100% 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?

Clearly states it removes a single line from the basket by index, explicitly distinguishing from clear_cart (which would remove all lines). References get_cart for index lookup, making the action 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?

Provides clear context: use to remove one specific line via index, and references get_cart. However, it does not explicitly mention alternatives like clear_cart for removing the whole cart, so it lacks explicit when-not guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: lat/lng preferred, address geocoding via OSM, no login needed for public search, and the location-scoped nature of favorites when credentials are configured. This adds meaningful context beyond the schema, though it omits potential details like rate limits or error 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?

The description is three sentences, with the primary purpose front-loaded. Each sentence delivers distinct value: what it finds, how to locate, and authentication/favorites behavior. There is no redundancy or fluff; it is appropriately detailed for the tool's complexity.

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

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

Given 15 parameters and no output schema, the description covers the essential usage modes and auth variations. It mentions the is_favorite flag and favorites_only behavior, which hints at the result structure. It does not describe the full return format or pagination, but for a search tool this is a minor gap; the core functionality is well explained.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by noting lat/lng are 'preferred,' explaining that address is geocoded via OpenStreetMap, and clarifying that favorites_only requires authentication and that favorites are inherently location-scoped. These details go beyond the property descriptions in the schema.

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

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

The description opens with a specific verb+resource: 'Find restaurants/shops that deliver to a location on efood.gr.' This clearly distinguishes it from sibling tools like cart, order, and menu operations. It also narrows the scope to location-based delivery, making the purpose unmistakable.

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

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

It gives explicit usage context: provide lat/lng (preferred) or a free-text address geocoded via OpenStreetMap, and optional filters. It also differentiates public search from authenticated search with favorites. While it doesn't explicitly say 'use this when searching restaurants,' the siblings make it the only search tool, so the guidance is clear and sufficient.

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