WaitApp

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

Annotations already declare it is a non-read-only, non-idempotent, non-destructive write, but the description adds the genuinely valuable workflow trait: this is a REQUEST the venue reviews and confirms, not an instant confirmation — an agent needs that to set user expectations and to handle polling via check_booking_status. It does not add auth/permission or rate-limit detail, so it stops short of a 5.

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

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

Three short sentences, zero waste, with the scoping exclusion front-loaded in the first parenthetical and the request-vs-confirmation caveat placed last as the key behavioral takeaway.

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?

Covers purpose, alternatives, and the approval-workflow semantic, but for a 7-parameter, 4-required write tool with 14% schema coverage and no output schema, the description leaves most parameters unexplained and does not indicate what the request response contains or how to follow up.

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

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

Schema description coverage is only 14% — only 'datetime' is documented — so the description carries the burden and largely fails it. It mentions the venue's city/countryCode provenance (fields that do not even appear in the schema's properties) but says nothing about restaurantId, guestName, guestPhone, guestCount, guestEmail, or notes.

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

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

Specific verb+resource ('Book a table reservation') with an explicit scope qualifier that rules out the closest sibling ('not a room/stay — use book_room for that'). An agent can distinguish this from book_room and book_service without opening any schema.

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 alternative (book_room) and the condition that selects it, states the upstream dependency (city/countryCode come from search_venues), and sets expectations that this is a review-and-confirm request rather than an instant booking. When-to-use and what-to-use-instead are both covered.

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?

Annotations declare readOnlyHint=false and non-destructive, non-idempotent. The description adds crucial context: it's a request not confirmation, no payment collected upfront, deposit may follow. Lacks disclosure of what happens on failure or request lifetime, but substantial value added.

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

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

Three well-structured sentences: purpose, cross-references, and key behavioral caveat. Every sentence earns its place; front-loaded with the main action.

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 9 parameters with low schema coverage, the description covers the key behavioral aspects (request nature, payment) but doesn't explain all parameters or failure modes. Still sufficient for an agent to understand the main flow and when to use it.

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

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

Schema coverage is only 22%, so more parameter semantics would help. Description mentions dates via check_room_availability and city/countryCode from search_venues, implying required fields like location. But doesn't explain the roles of restaurantId, roomFacilityTypeId, guestName, guestPhone, etc. Baseline 3 given the low coverage and minimal compensation.

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 verb+resource ('Submit a stay booking request') and distinguishes it from siblings by referencing check_room_availability and search_venues. The 'REQUEST not instant confirmation' framing is precise.

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 alternatives (check_room_availability for free dates, search_venues for city/countryCode) and states the condition. Makes clear this is a request subject to venue review, unlike potential instant booking siblings.

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

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

Annotations only declare the generic hint set (readOnlyHint=false, destructiveHint=false, idempotentHint=false), which is consistent with the description. The description adds genuinely non-derivable behavior: real slot is atomically reserved, confirmation is instant unlike book_room, and no payment is collected here (guest pays at the venue). This is meaningful operational context for money and reservation semantics.

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

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

Three dense sentences, front-loaded with the action and scope, followed by prerequisites and the two behavioral facts that matter (instant/atomic, no payment). No filler or restatement of the tool name.

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

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

There is no output schema to replace, and the description covers the confirmation and payment model well. The remaining gap is the unlabeled identifier naming (restaurantId on a spa booking tool) and the fact that half the parameters get no semantic treatment, which an agent must infer.

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

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

Schema coverage is only 25%, so the description must carry weight. It hints at guest semantics ('on behalf of a real guest') and points at check_service_availability for practitioner selection, but it never explains restaurantId vs serviceTypeId (venue/service identifiers for a spa), guestPhone (a required param), or guestEmail/notes — the remaining required parameters stay undocumented in both the schema and the description.

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

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

States a specific verb+resource ('Book a ... SERVICE slot on behalf of a real guest') and immediately scopes it against siblings, naming check_service_availability, search_venues, and explicitly contrasting with book_room. An agent can distinguish it from book_reservation/book_room without opening any schema.

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?

Gives an explicit prerequisite chain: use check_service_availability to find free slots, search_venues to obtain the venue's city/countryCode. It also states the differentiator vs the alternative (book_room) — instant vs presumably non-instant confirmation — which is exactly the routing information an agent needs.

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?

Adds substantial context beyond annotations: refund is flagged for venue review but never instant/automatic, the first confirm-mode call is a non-destructive preview returning what would cancel, and there is a 3-per-day cap. These details are consistent with destructiveHint=true and idempotentHint=true and materially deepen understanding.

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?

Leads with the core action, then layers eligibility rules, refund behavior, and the confirmation/rate-limit mechanics in a logical order. Dense but nearly every clause carries decision-relevant information; slightly long for a single sentence chain.

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?

With no output schema, the description compensates by explaining what the preview call returns and what cancellation does not do (no instant refund). Eligibility, rate limits, and confirmation semantics are all covered, leaving no critical gap for correct 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?

Schema coverage is 80%, so baseline is 3, but the description adds real meaning to the confirmed flag by explaining the preview-then-confirm flow rather than just 'records agreement'. reason and restaurantId disambiguation are left to the schema, keeping it from a 5.

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 verb (Cancels) and resource (order) scoped to the connected person's own order, immediately distinguishing it from booking/listing siblings. The scope qualifier prevents confusion with any admin-side cancellation.

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?

Gives clear when/when-not conditions: free until the venue or rider starts, refused once collecting/food held, and distinguishes confirm-mode vs full-control behavior. It doesn't explicitly name sibling alternatives (e.g. list_my_orders, track_order), leaving that inference to the schema, but the situational guidance is strong.

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

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

Annotations already cover readOnly, idempotent and non-destructive, so the description's job is to add what they don't say. It does: no authentication is required, phone is verified together with the code, and because there is no output schema it explains the returned status and that 'pending' means the venue has not yet responded.

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 verb and lookup key, then prerequisites and return behavior. Every clause carries information — scope, example, credentials, auth, and return semantics — with no filler.

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

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

With no output schema, the description properly explains what comes back, and it covers auth and all three inputs. The remaining gap is disambiguation from track_order/list_my_orders in a crowded sibling set, which an agent cannot resolve from the description alone.

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

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

Schema coverage is only 33% (only phone is documented in the schema), so the description must compensate — and largely does: bookingCode is the code returned when the booking was placed (with example WA-K4M2), restaurantId is where it was placed, and phone is what it was made with, checked together with the code. Format details for restaurantId and bookingCode remain thin.

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 verb and resource — looks up the status of a booking or order — and clarifies it covers tables, stays, services, delivery requests and pre-orders. It does not differentiate itself from overlapping siblings such as track_order or list_my_orders, so an agent facing those alternatives must infer the distinction.

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 useful invocation context: the code must be the one returned at placement, plus restaurantId and phone, with no sign-in. However, with 27 siblings including track_order and list_my_orders, it never states when to prefer this tool over those, nor any when-not conditions.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds no behavioral context beyond restating the purpose—it does not describe what 'remaining capacity' means, how it is computed, or what the response contains.

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?

A single front-loaded sentence with no wasted words. It is appropriately sized 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?

For a simple read-only check with rich annotations and no output schema, the description conveys the basic purpose but omits what the tool returns (e.g., remaining count) and lacks any usage context. Minimum viable, but with clear 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?

With one parameter (eventId) and 0% schema description coverage, the description must compensate. 'For a specific event' only echoes the parameter name and adds no format, constraints, or identifier expectations.

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 verb ('Check') and resource ('remaining capacity for a specific event'). The resource 'event' distinguishes it from siblings like check_room_availability and check_service_availability, but it does not explicitly name or contrast those 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?

Provides no guidance on when to use this tool versus alternatives such as check_room_availability or list_events. The only implied usage is the literal purpose, with no context, prerequisites, or 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description's only added behavioral content is the 'real availability vs. type existence' distinction, which is useful but modest. No mention of permissions, rate limits, or result shape.

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 tight sentences with no filler; the availability distinction is front-loaded and the prerequisite call is the trailing actionable instruction.

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

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

There is no output schema, so the description carries some return-value burden — it does indicate the result is which physical rooms are actually free, which is the key semantic. It stops short of describing the result structure (e.g., per-room list vs. aggregate count), a minor gap for a 4-param read 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 only 50%, with restaurantId and roomFacilityTypeId undocumented in the schema. The description partially compensates by explaining where roomFacilityTypeId comes from (list_room_types), but adds nothing about restaurantId, and checkIn/checkOut semantics are fully covered by 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?

Specific verb (check) plus resource (physical rooms/facilities of a given catalog type) and an explicit scope qualifier: 'real availability, not just that the type exists.' This distinguishes it cleanly from the sibling list_room_types and from check_event_availability/check_service_availability.

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

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

Explicitly states the prerequisite: 'Use list_room_types first to get roomFacilityTypeId.' The 'not just that the type exists' clause further clarifies the boundary with that sibling. It doesn't, however, say anything about when to book (book_room) versus just check, so the routing guidance is strong but not exhaustive.

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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the bar is lower. The description still adds behavioral value by disclosing the query's temporal semantics — it is a point-in-time slot probe, not a range scan — which affects how the agent interprets the result.

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 tight sentences: purpose and domain first, the key disambiguation second, the lookup prerequisite last. No filler and nothing important buried.

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

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

There is no output schema, so the description carries the burden of describing what comes back — it never states whether the result is a boolean, a free slot, or a list of alternatives. The serviceTypeId workflow is covered and annotations handle safety, but the return-value gap leaves the definition merely 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?

Schema coverage is only 33%: only startIso is documented in the schema. The description compensates partially by defining serviceTypeId as a list_room_types entry with kind 'service' and pointing to list_room_types to obtain it. restaurantId is left entirely unexplained, so the compensation is incomplete.

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 names a specific verb and resource ('check whether a bookable SERVICE ... has a free slot at a specific start time') and explicitly disambiguates from the sibling check_room_availability by contrasting time-slot vs. date-range semantics. An agent can distinguish this from the room and event availability tools without opening any schema.

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 a clear precondition-workflow ('Use list_room_types first to get the service's id') and an implicit routing cue ('not date-range like rooms'). It stops short of naming the alternative tools or stating when this tool should NOT be used, so it is strong but not fully explicit.

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?

Annotations already declare destructiveHint=false and idempotentHint=true, so the safety profile is partly covered. The description adds genuinely new context: the tool charges nothing even when online payment applies (the guest pays via a returned payment link), the venue must accept after placement, and tracking continues via orderCode. That is material behavioral disclosure beyond the 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?

Four sentences, no filler, and the primary action is front-loaded. The payment-charges-nothing caveat is appropriately attached to the payment-link sentence rather than buried. Slightly dense but every sentence carries actionable information.

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

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

With no output schema, the description still discloses the meaningful return behavior (payment link when payment is online) and the post-placement lifecycle (venue acceptance, track_order via orderCode). For a one-parameter mutation with sibling tools, nothing essential is missing.

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

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

Schema description coverage is 0% for the single draftId parameter, but the description compensates by explaining exactly where the value comes from (draft_delivery_order output or place_delivery_order). The retry/idempotency note also clarifies the semantic meaning of reusing the same draftId, which the bare string schema does not.

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 gives a specific verb+resource ('Places a drafted delivery order exactly as drafted') and immediately differentiates itself from the similarly named place_delivery_order and draft_delivery_order by explaining where its draftId originates. An agent can distinguish confirm_delivery_order from its two closest siblings without opening a schema.

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 clearly states the provenance of draftId (from draft_delivery_order, or from place_delivery_order when the connection confirms each decision), which effectively routes the agent between related tools. It stops short of an explicit 'do not use this to create a fresh order' exclusion, but the context is clear.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuine value beyond that by clarifying the side-effect boundary: orders already placed are not affected. It stops short of stating permission requirements or failure behavior for an unknown 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?

Two short sentences with zero padding; the destructive action and its scope are front-loaded, and the mitigating side-effect note follows immediately. Every sentence earns its place.

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

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

For a one-parameter destructive tool with full schema coverage, no output schema, and annotations carrying the safety hints, the description covers purpose, id source, and blast radius. Only failure/error semantics (e.g., unknown or already-deleted id) are left unstated, which is a minor gap.

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%, and the single `id` param is fully documented there, so baseline 3 applies. The description's 'use the id from list_saved_locations' largely restates the schema rather than adding format or constraint detail.

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 verb (Removes) and resource (saved delivery location) scoped to the connected person. It also implicitly distinguishes itself from the read-only sibling list_saved_locations and save_location, so an agent can tell them apart without opening any schema.

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 tells the agent where the `id` comes from (list_saved_locations), which is useful routing. However, it never states when deletion is appropriate versus alternatives, whether confirmation is needed, or what happens if the id is stale or invalid — usage is merely implied.

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

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

Annotations only state it is a non-destructive, non-idempotent, non-read-only write. The description adds substantial beyond that: no payment is sent or approved by this tool or the assistant, the account prerequisite, the failure modes (venue closed, no delivery, address outside area), and the rule that the delivery fee is always paid to the rider on delivery.

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?

Front-loaded with what the tool does and returns before the operational details, and every clause carries information. However, it is delivered as one dense paragraph of long, parenthetically nested sentences, which makes it harder to scan than it needs to be.

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?

With no output schema, the description fully enumerates the return payload (items, delivery fee, total, distance, ETA, draftId), plus prerequisites, failure behavior, and payment flow. Nothing an agent needs to call this correctly is missing.

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 57%, so the description does useful compensating work: it explains that selectedOptions carries group name + choice name, that required=true groups must be chosen, and that either a full address or savedLocationId is needed. It does omit the mobile_money enum value when listing payment options, though the schema's own enum description covers 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?

States a precise verb+resource ('Prices a food/drink DELIVERY order from the venue's menu') with the explicit qualifier 'without placing anything', which isolates it from confirm_delivery_order and place_delivery_order in the sibling set. An agent can identify the tool without opening any schema.

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 routes between the three sibling tools: this one drafts, confirm_delivery_order places the returned draftId, and place_delivery_order does both steps in one call. It also names list_menu_items as the source of item ids and optionGroups, and list_saved_locations for savedLocationId.

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?

Despite terse annotations, the description discloses substantial behavior: nothing is placed or reserved, the slot is validated against lead time/capacity/items-sold-today, the order is priced, delivery fees are paid to the rider, a connected WaitApp account is required, and the assistant sends/approves no payment. That is rich context the annotations do not carry.

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?

Front-loads the core action and keeps every clause informative, but it is a single dense paragraph with layered parentheses that is harder to scan than a short bulleted structure would be.

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 9-parameter, no-output-schema tool, it covers inputs, prerequisites, validation behavior, pricing, payment flow, and the return payload (slot/ready time, items, total, due-now vs on-collection, draftId) – nothing needed to invoke it correctly is missing.

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 schema coverage at 44%, the description compensates well: it explains method defaults and delivery requirements (deliveryAddress or savedLocationId), payment defaults and mechanics, why guestPhone is required, and where slotInstanceId comes from. It omits the mobile_money payment option that the schema enum exposes.

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?

Opens with a precise verb+resource ('Drafts a pre-order for a time slot') and immediately scopes it against the placing step ('Nothing is placed or reserved', 'Returns a draftId for place_preorder'), which separates it cleanly from place_preorder and draft_delivery_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?

Gives clear context: the slot must come from list_preorder_slots (slotInstanceId) and the result feeds place_preorder, plus when delivery applies and when online payment is required. It does not explicitly state when to prefer this over draft_delivery_order, so it stops short of full routing 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: it spells out the two permission modes (immediate vs return-for-agreement), that limits and remaining-today quota are reported, and that WaitApp connection status is included.

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?

A single, front-loaded sentence that moves from the core meaning (what the person allowed) to the mechanics (immediate vs confirm) to the extras (limits, remaining, WaitApp). It is dense and slightly run-on with stacked parentheticals, but no sentence is wasted.

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?

With no output schema, the description carries the burden of describing the return values, and it does so adequately: permission mode, limits, remaining allowance today, and account connectivity. It stops short of specifying field names or structure, but an agent has enough to know what the call yields and when it is relevant.

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 takes zero parameters, so schema coverage is complete by definition and no parameter explanation is required. Baseline 4 applies; the description adds nothing here but nothing is missing either.

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

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

The description clearly identifies this as a read of the connection's authorization state — what the person allowed this connection to do, plus limits, remaining quota, and WaitApp account linkage. It is unmistakably distinct from the booking/ordering siblings since it performs no action itself. It never states a crisp verb+resource ('get permissions'), phrasing the purpose as content instead, which keeps it just below 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?

There is no explicit when-to-use statement or named alternative. The description implies the value of calling it (knowing whether orders go through immediately or need confirmation) which lets an agent infer it should be checked before placing or confirming orders, but this is left to inference rather than 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety and repeatability are covered. The description adds genuinely new behavioral context: the tool itself charges nothing and sends no prompt, and the actual payment happens when the human opens the returned link and sees the exact charge. That clarifies the human-in-the-loop nature of the operation, which annotations could not convey.

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

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

Three sentences, front-loaded with the purpose and eligibility, then the human-payment mechanism, then the parameter-lookup guidance. Efficient and well ordered, though the payment-mechanism sentence is slightly verbose relative to the rest.

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?

With no output schema, the description correctly carries the return-value burden by stating it returns the payment page link. Eligibility, the no-charge/no-prompt caveat, and how to supply each lookup key are all present. Only minor gaps remain, such as whether the link expires or how long it is valid.

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% and all three parameters are documented in-schema, so baseline is 3. The description goes further by explaining the lookup logic: orderId comes from list_my_orders, and restaurantId is only needed alongside orderCode when the same code exists at two venues. That disambiguation rule is real added meaning beyond the schema.

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

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

States a specific verb and resource (returns the payment link for a WaitApp payment page) and sharpens it with eligibility criteria: only the connected person's own orders that still have an amount to pay now, either an online-payment order or a pre-order with a deposit. This scope is distinct enough from sibling get_ticket_checkout_link that an agent can route between them without opening schemas.

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?

Gives clear context for when the tool applies (orders with an outstanding amount) and explicitly disclaims behavior that might otherwise attract the agent away from it: it charges nothing and sends no payment prompt. It also directs the agent to list_my_orders as the orderId source. What it lacks is an explicit exclusion or alternative for the ticket-payment sibling, leaving one routing decision to inference.

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?

Annotations already cover readOnly/idempotent/non-destructive, so the bar is lower; the description adds genuinely new behavioral context by stating the tool 'charges nothing and sends no payment prompt' and that the guest completes the purchase. It doesn't mention link expiry, auth requirements, or whether the same event+tier yields a stable link.

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 tight sentences, front-loaded with the return value, followed by the critical behavioral clarification and the sibling pointer. No filler or restatement of the name.

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

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

With no output schema, the description carries the burden of explaining the return value and does so ('the link ... with the chosen ticket type and quantity filled in'). Combined with the no-payment clarification it is nearly complete; only link lifetime and permission prerequisites are unaddressed.

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

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

Schema coverage is only 33% (eventId and quantity undocumented, tierId documented). The description partially compensates by describing the link as pre-filled with 'the chosen ticket type and quantity' and by pointing to check_event_availability for tierId, but it adds nothing for eventId or for the 1-20 quantity bounds beyond the schema's own min/max/default.

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 verb and resource ('Returns the link to WaitApp's ticket checkout page for an event') plus the pre-filled scope (tier type and quantity). It also names the sibling it depends on ('check_event_availability shows what is left and the ticket types'), so an agent can route correctly without opening either schema.

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?

Gives a clear use context (guest opens the link and pays themselves) and explicitly routes to check_event_availability as the source of tierId. It stops short of naming the negative alternative (get_payment_link) or when not to use this tool, so it is strong but not fully explicit on 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that results are limited to upcoming/published and include both ticketed and free events, which is useful context. It says nothing about pagination behavior despite a limit parameter, so there is a gap beyond the 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?

A single sentence that front-loads the resource and scope, with the conditional behavior attached cleanly. No filler or redundancy.

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

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

For a read-only list tool whose annotations already establish safety, the essentials are present, but there is no output schema and no mention of result ordering or how the limit interacts with pagination. An agent can call it, but not fully predict the result shape.

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

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

Schema coverage is 0%, so the description must carry the load. It explains restaurantId's omission semantics (all venues), which is real added value, but it never addresses limit — no mention of pagination, the default of 20, or the cap of 50. Partial compensation only.

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 verb (List) and resource (events), plus meaningful scope qualifiers: upcoming, published, ticketed or free. It does not, however, distinguish itself from close siblings like check_event_availability or buy_ticket, leaving some overlap for the agent to infer.

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

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

The description gives one concrete usage rule — omit restaurantId to search across all venues — which is genuinely helpful. But it offers no guidance on when to use this versus the event-availability or ticketing siblings, so it stops short of full when/when-not coverage.

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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds substantial context beyond them: unavailable items are omitted, optionGroups/selectedOptions ordering semantics, required=true groups must be chosen, and the pre-order-only constraint of soldAheadOnly items. This is real behavioral disclosure, not restatement.

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?

Front-loaded with purpose and the core workflow, then the pre-order caveat and pagination. It is dense and slightly run-on but every clause carries actionable information; nothing is 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?

With no output schema, the description does the work of describing the shape of results (category names and counts, item optionGroups, omission of unavailable items) and pagination. Adequate for a read-only list tool, though it omits limit/offset defaults and total-count behavior.

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

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

Schema coverage is only 40% (limit, offset, restaurantId undocumented in schema). The description partially compensates by explaining that category/query are filters and that limit/offset paginate, but it never states defaults, caps, or what restaurantId must reference, so the coverage gap is not fully closed.

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 verb+resource and scopes it to a single restaurant's menu via restaurantId. It does not explicitly name the closest sibling (search_menu) or contrast cross-venue search with this per-restaurant listing, so the sibling differentiation is only implicit.

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?

Gives an explicit workflow: call with just restaurantId to see category names and counts, then narrow with category/query instead of reading the whole menu. It also routes soldAheadOnly items through list_preorder_slots -> draft_preorder -> place_preorder, naming the alternatives and the condition that selects them.

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?

Annotations already cover the safety profile, and the description layers on substantial behavior beyond them: newest-first ordering, that a kitchen+bar pair collapses into one entry, delivery-specific fields (address, fee, stage), and that item fields are shaped to feed draft_delivery_order. That last point is a genuinely useful cross-tool contract.

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 scope and ordering are front-loaded and the return-shape detail is dense but earns its place given there is no output schema. Slightly long, with the delivery and item-shape sentences packed tightly, but no filler.

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

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

With no output schema, the description takes on the full return-value burden and delivers: per-order fields, item structure, delivery-specific fields, and order aggregation rules. An agent knows both how to call it and what comes back.

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 83%, so the schema carries most of the burden, but the description adds real meaning by glossing 'text' as item-or-venue name and tying 'before' to nextBefore paging. It does not clarify the since/before precedence or the limit cap beyond schema defaults.

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 verb and resource ('List... order history'), names the scope ('the connected person's own... newest first') and explicitly excludes other people's orders. An agent can distinguish it from track_order or cancel_order without opening any schema.

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?

Enumerates the available filters (venue, status, text, date) and explains the paging mechanism ('page back with nextBefore'), giving clear browsing context. It stops short of naming sibling alternatives such as track_order when a single order's live state is wanted.

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?

Annotations already guarantee read-only/idempotent safety, and the description adds substantial behavioral context beyond them: lead times that can span days, items unavailable on certain days, per-slot limits and capacity, deposit or full-payment terms, and that unavailable slots are returned with a reason. This is exactly the extra context a read-only listing tool should disclose.

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 purpose and preconditions are front-loaded, and the length is justified given there is no output schema to carry the return shape. However, the usage/return detail is delivered as one sprawling semicolon-chained sentence that takes effort to parse.

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

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

For a 3-param read-only tool with no output schema, the description covers the prerequisite (which venues), input intent, and the full result shape (schedule summary, slotInstanceId, readyAtLocal, orderByLocal, places left, payment terms, unavailable-with-reason), including a plain-words schedule field for guest-facing description. Nothing needed to call or interpret it is missing.

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 67% schema coverage, the description adds real meaning: it explains why items (menuItemId + quantity) matter — each slot is validated against them — and that method (pickup/delivery) governs which slots are marked unavailable. restaurantId is left implicit, but its role is obvious from context.

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

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

The description states a specific verb+resource ('list pre-order time slots') and immediately scopes it to a distinguishable venue class (scheduled pre-orders: bakeries, caterers, identified via list_menu_items soldAheadOnly). An agent can tell this apart from the many availability/pre-order siblings without opening the schema.

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

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

It gives clear triggering context (only venues that take scheduled pre-orders) and tells the agent how to drive the call — pass the items so slots are validated against lead time, day availability and capacity, or leave empty for a raw schedule view. It does not explicitly name a competing sibling to use instead (e.g. book_reservation or check_event_availability) or state when not to use it, so it stops short of a full when/when-not/alternative statement.

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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world. The description adds the customer-visibility filter, which is useful extra context, but does not discuss pagination, ordering, or return shape.

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 dense sentences with zero filler; the visibility scope and the prerequisite both earn their place and are front-loaded.

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

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

For a simple single-param read-only list tool, the description covers purpose, scope, and prerequisite. Minor gaps in return-format expectations are acceptable given no output schema and safety already covered by annotations.

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

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

Schema coverage is 0% and the only param (restaurantId) is undocumented in the schema. The description partially compensates by telling the agent to obtain it via search_venues, but does not state format or constraints. Baseline 3 given one simple required param.

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 verb (List) and resource (bookable room/facility catalog), with a clear scope qualifier ('only entries visible to customers') that distinguishes it from availability-checking siblings like check_room_availability.

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 use search_venues first to obtain the restaurantId, providing a clear workflow precondition. It does not, however, name when-not-to-use or contrast with the book_* siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed world, so the safety profile is covered. The description adds meaningful non-annotation context: the privacy scoping ('Only ever shows this person's own') and the shape of the returned records, which matters because no output schema exists.

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 filler. The returned payload is front-loaded, the workflow hand-off follows, and the access-scope caveat closes it out.

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?

With no parameters and no output schema, the description carries the return-value burden itself and does so by listing the fields. Access scope, purpose, and the downstream id hand-off are all present, leaving nothing an agent needs missing.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The only identifier mentioned (savedLocationId) belongs to other tools, not this one's schema, so it does not add parameter meaning here.

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

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

The description states a concrete resource (the connected person's saved delivery locations) and enumerates the returned fields (label, address, notes, default), so an agent knows exactly what comes back. It also names the downstream siblings (draft_delivery_order, place_delivery_order) that consume the ids, distinguishing this read tool from the save_location/delete_saved_location pair.

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 a clear use case: fetch an id here and pass it as savedLocationId to draft_delivery_order or place_delivery_order instead of typing an address. That is an explicit routing rule, though it never states when NOT to use this tool (e.g., free-text addresses are still valid).

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?

Annotations only declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the description carries real weight and delivers: it discloses that this tool charges nothing (the guest pays on WaitApp's payment page), that a payment link is returned for online payment, that the venue must still accept the order, and that idempotencyKey is required and de-duplicates retries. The idempotentHint=false annotation is not contradicted — caller-supplied-key idempotency is a separate guarantee from blanket tool idempotency — and the description makes that distinction clear.

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?

Front-loaded with the core action and the permission branch, and every subsequent sentence (draft path, idempotency, payment link, venue acceptance) carries information an agent needs. It is dense and slightly overlong, with a couple of tightly packed clauses, but no sentence is 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 complex, multi-branch mutation with no output schema, the description covers the important return shapes (draft summary with draftId, payment link, orderCode for tracking) and the post-placement lifecycle. It stops short of error/failure behavior and does not explain address-sourcing inputs, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is only 38%, so the description should compensate more than it does: it explains idempotencyKey's required/reuse semantics (already in the schema) and touches the payment field ('when payment is online'), but says nothing about deliveryAddress vs savedLocationId, guestName/guestPhone, items quantity bounds, or the other payment enum values. Baseline 3 is appropriate — it adds some meaning over the schema but leaves documented gaps.

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 first sentence names a specific verb+resource (order food for delivery) and immediately distinguishes this tool from its close siblings: quote_delivery (prices/quotes only) and draft_delivery_order (draft only), by stating it prices, quotes the fee, and then places. An agent can tell it apart without opening any schema.

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

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

It explicitly states the branch condition that selects behavior — permission chosen at connect time, visible via get_connection_permissions — and names the follow-up tool (confirm_delivery_order) for the confirm-each-decision path and track_order for post-placement. It also notes 'Same inputs and rules as draft_delivery_order', which routes the agent correctly between the draft and place variants.

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?

Goes well beyond the annotations: it discloses that no charge is made (a payment link is returned and the guest pays it themselves), that the held slot is released and the order cancelled if payment is not made in time, that partial failures release the slot with nothing charged, and that retrying the same draftId never double-creates an order. The idempotentHint=true annotation is thus reinforced with the mechanism (draftId) behind it.

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?

Five tight sentences, front-loaded with the core action, then payment behavior, failure semantics, idempotency, and the follow-up tool. Each sentence adds a distinct behavioral fact; nothing is filler or restated from the title.

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?

With no output schema and no schema descriptions, the description compensates by describing the returned payment link and the success/failure outcomes, including slot release and cancellation. An agent has everything needed to call this correctly and set expectations for the result.

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

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

Schema coverage is 0% for the single parameter, so the description must carry the load, and it does: it identifies draftId as the output of draft_preorder and explains its idempotency semantics ('retrying with the same draftId never creates a second order'). It only lacks a note on whether the id is reusable after a successful placement or how it is obtained exactly.

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 verb (places) and resource (pre-order) and explicitly anchors it to the drafting sibling: 'a pre-order drafted with draft_preorder, exactly as drafted'. It also names the downstream sibling track_order, so the agent can distinguish this step from drafting and from tracking.

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 clearly establishes the sequencing condition (use this after draft_preorder, and the draft is placed verbatim, so no further editing happens here) and routes to track_order afterwards. It does not, however, explain when a pre-order is preferable to sibling booking tools like book_reservation or list_preorder_slots, so it stops short of explicit alternatives/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?

Annotations already declare readOnly, idempotent, non-destructive, non-open-world. The description adds genuine context beyond them: the auth prerequisite ('Needs a connected WaitApp account'), the cart-free nature, and the full set of returned facts (fee, distance, ETA, in-area check, open-now status). It does not contradict any annotation.

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

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

Four sentences, each contributing: the core return, the cart-free positioning, the output extras, and the auth requirement. The core value is front-loaded. It is slightly dense but wastes little.

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?

With no output schema, the description responsibly enumerates what is returned (fee, distance, ETA, delivery-area check, open-now) and notes the account prerequisite. For a 3-param read tool this is close to complete, missing only guidance on the undocumented restaurantId source.

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 67%: deliveryAddress and savedLocationId are already documented, while restaurantId has no schema description. The description mentions 'one venue' and 'an address or a saved location' but adds no format, id-source, or mutual-exclusivity detail beyond the schema. Baseline 3 is appropriate when the schema carries most of the parameter meaning.

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

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

States a specific verb+resource: returns delivery fee, distance and estimated delivery time from one venue to an address. It explicitly distinguishes itself from draft_delivery_order by noting it works 'with no cart' and returns 'the same one a draft order then shows.' An agent can tell this apart from its order-drafting siblings without opening a schema.

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?

'A quick way to compare venues before building an order' gives clear when-to-use context and implicitly positions it upstream of draft_delivery_order. It also notes it accepts a saved location as an alternative input. It stops short of explicit when-not-to-use exclusions, but the routing intent is clear.

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

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

Goes well beyond the annotations. Annotations declare a non-read-only, idempotent, non-destructive write; the description explains why it is idempotent (one rating per order, repeats return the existing one) and discloses the two-phase confirmation behavior where the first call returns scores but submits nothing. That is exactly the extra behavioral context a mutation tool needs.

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 tight sentences, front-loaded with the action and its eligibility constraint, then the rating fields, then the idempotency and confirmation rules. No filler.

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

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

With no output schema, the description carries the return-behavior burden and does so for the confirmation case (first call returns the scores). For a 9-parameter mutation tool it is nearly complete, though the identifier parameters (orderId vs orderCode vs restaurantId) are left to the schema.

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

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

Schema coverage is only 44%, and the description helpfully compensates for the undocumented fields: it defines food/deliverySpeed/packaging as 1-5 scores, comment as optional and short, riderRating as optional, and explains what confirmed: true does. It does not clarify the relationship between orderId, orderCode and restaurantId, which the schema partially handles.

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 verb (rate) and resource (an order), plus the qualifying constraints: it must be the connected person's own and must be DELIVERED. It also enumerates the rated dimensions, so an agent can distinguish this from sibling tools like track_order or confirm_delivery_order without opening the schema.

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?

Gives clear operative context: one rating per order, a repeat returns the existing one, and the confirm-each-decision flow requires a follow-up call with confirmed: true. It does not name an alternative tool or an explicit when-not-to-use condition, but no sibling overlaps this action.

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?

Annotations declare non-read-only, non-destructive, idempotent, and closed-world behavior, so the description needn't repeat safety. It adds valuable context beyond annotations: an upsert-by-label model, a cap of 10 locations, and notes for the rider. It omits what happens when the limit is reached and whether a new save can overwrite, which are minor but notable.

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-loading the core action and then adding the update-by-label nuance, the 10-location limit, and the notes purpose. Each sentence adds information, though the order is slightly non-linear (limit after update). No filler.

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

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

For a four-parameter mutation with full schema coverage and annotations covering safety, the description covers upsert, quota, and notes meaning. It lacks explicit guidance on what happens at the 10-location cap and does not mention makeDefault, but overall it gives an agent enough to call 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 schema already documents all four parameters. The description adds the meaning of notes and the label-as-identifier behavior, which complement the schema, but makeDefault is not mentioned in the description. Baseline 3 applies since the schema does the heavy lifting.

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

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

The description states a specific verb (saves) and resource (delivery location) and scopes it to the connected person's WaitApp account. The purpose is unmistakable and distinguishes the tool from siblings like delete_saved_location or place_delivery_order.

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

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

The description implies usage by saying saving a label updates an existing location and that later orders can use it, but it does not explicitly state when to use this tool versus alternatives or prerequisites such as an established connection. It offers no 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?

Adds rich behavior beyond annotations: category-name matches ranked first, close equivalents reported in alsoSearched, per-venue item counts, soldAheadOnly meaning, and nearest-first ordering from a position or saved location. Annotations already confirm read-only and idempotent safety, but the description supplies the operational and return-shape context an agent needs.

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?

Front-loads purpose and packs useful details into a single dense paragraph with little repetition. It is longer than typical because the tool is complex, but every sentence carries signal; structure could be improved with bullets, keeping it from a 5.

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?

With no output schema, the description carries the return-value burden and does so thoroughly: venue properties, matching items, price, required choices, matchingItems and moreMatches, and soldAheadOnly. Together with annotations and 80% schema coverage, an agent has enough to call 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 coverage is 80%, so most parameters are already documented. The description adds meaning for perVenue (items per venue plus moreMatches), near/saved location ordering, city/countryCode narrowing, and query equivalence. It leaves maxVenues undocumented, but otherwise supplements the schema effectively.

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 verb and resource: finds venues selling a dish or cuisine by searching menus of live venues, and explicitly excludes event organisers. It also distinguishes itself from list_menu_items, which is named for full menus, so an agent can select it for dish discovery.

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 recommends city or countryCode narrowing and names list_menu_items as the alternative for full menus and item options. It also scopes results to live venues and never event organisers. However, it does not explicitly contrast with search_venues, leaving one sibling comparison to inference.

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?

Annotations already cover readOnly/idempotent/safe, so the description uses its space well: it discloses forgiving name matching, the didYouMean fallback when nothing matches closely, distance-based sort order, the sortedBy indicator, openNowBasis provenance (venue switch vs hours vs no hours assumed open), and opensAt for closed venues. These are behavioral traits not derivable from annotations or schema.

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

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

Purpose and matching behavior are front-loaded, then filters, then output semantics — a sensible order with almost no filler. The middle sentences are dense run-ons (openNowBasis/opensAt/hoursSummary packed into one clause chain), so it is slightly harder to scan than it needs to be.

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?

No output schema exists, and the description compensates fully by describing the per-venue return: supported services, open-now status and basis, next opening time, hours in words and per day, distance, city and countryCode, plus didYouMean and sortedBy. An agent has everything needed to call 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?

With 80% schema coverage the baseline is 3, and the description adds real meaning on top: nearLat/nearLng must be paired and trigger distance sorting, savedLocationId refers to list_saved_locations for the connected person, and openNow interacts with openNowBasis. Limit and the exact city matching rule are left entirely to 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 opening sentence gives a concrete verb (search) and resource (WaitApp venues), names the entity types (restaurants, hotels, lodges), and enumerates the filters and matching modes. It is unmistakably distinct from siblings like search_menu and quote_delivery, which it also names as separate 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?

It explicitly states 'Empty query lists venues' (a non-obvious invocation mode) and routes two adjacent needs elsewhere: 'For the delivery fee to an address use quote_delivery' and 'To find who sells a dish, use search_menu.' The default-location fallback condition ('with neither, the connected person's default saved location is used') also clarifies behavior an agent would otherwise have to guess.

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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: the privacy boundary ('rider's phone number and exact location are never returned') and that the response shape varies by order type. It stops short of covering error or not-found behavior.

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

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

A single front-loaded sentence with a parallel per-order-type structure that makes it easy to scan. The privacy clause is well placed at the end. It is dense but every clause carries information, with no filler.

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

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

With no output schema, the description does the heavy lifting by enumerating the returned fields for delivery, pre-order, and other orders, which is exactly what an agent needs here. The remaining gap is identifier selection across the three optional parameters, which matters given that none are required.

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 each of the three parameters is already documented, and the description adds nothing about them. It leaves the real ambiguity unaddressed: with zero required parameters, when should an agent pass orderId versus orderCode plus restaurantId. Baseline 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 states a specific resource and scope: retrieving live tracking state for an order the connected person placed, broken out by order type. It is clear what the tool does, but it never names or contrasts with the closest sibling (list_my_orders or check_booking_status), so an agent must infer the boundary.

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?

Usage is only implied: 'the connected person's own order' hints this is for orders already placed, but there is no explicit statement of when to use this versus list_my_orders or check_booking_status, and no guidance on what to do if the caller lacks an order ID. Minimum viable context without exclusions or alternatives.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuine behavioral context beyond that: it returns up to 3 images resized small, or a note that none exist, which sets expectations for the response. Not a full 5 since load/format behavior is only sketched, but it clearly earns credit over the 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?

Front-loads the OPTIONAL marker and the core action, then layers usage, alternatives, and return behavior in a compact block. 'so you can look at them and describe them to the guest' is slightly redundant with the preceding clause, but overall most sentences earn their 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 3-param read-only tool with no output schema, the description covers purpose, when/when-not, the id source, and return shape (up to 3 small images or a none-note). The only real gap is maxPhotos semantics, which leaves the agent guessing whether to set it.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It does explain where the id comes from (the four list/search tools) and indirectly communicates the kind domain via 'menu item, room/facility type, event or venue,' but maxPhotos is never mentioned despite its 1-3 range and default of 2; 'up to 3 images' hints at the cap without tying it to the 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?

States a specific verb (fetch) and resource (small version of the actual photo) and enumerates the four entity kinds it applies to. It also distinguishes itself from the passive imageUrl/photos/coverImageUrl links exposed by other tools, so an agent can tell why this tool exists separately from list_menu_items or search_venues.

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

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

Explicitly states when to use it ('when the guest asks what something looks like') and when not to ('To just show a picture, the imageUrl / photos / coverImageUrl links in the other tools are enough'). It even marks itself OPTIONAL, and names the sibling tools (list_menu_items, list_room_types, list_events, search_venues) that supply the required id.

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