Dubai Table

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds the status vocabulary (pending/confirmed/seated/cancelled) which is useful context, but does not discuss auth needs or error behavior for invalid refs. With annotations carrying the safety profile, a 3 is appropriate.

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?

One dense sentence, front-loads the lookup purpose and packs in the status vocabulary efficiently. Slightly terse 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?

For a read-only lookup with an output schema, the description covers the essential inputs and returned status values. It doesn't explain failure modes for unknown references or phone mismatches, leaving some gaps in an otherwise simple tool.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that ref follows an RZ-XXXXX format and that phone is the guest's phone number, which is genuinely beyond the bare schema strings. However, it doesn't specify format requirements or validation for either, so it only partially fills the gap.

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 clear verb (retrieve status) and resource (booking request), scoped by reference. Distinguishes itself from siblings like request_table and cancel_booking, though it doesn't explicitly name an alternative.

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

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

Usage is implied by the required ref+phone pair, implying it's a lookup tool, but there is no explicit when-to-use or when-not-to guidance relative to 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 destructive=true, idempotent=true, readOnly=false, so the safety profile is covered. The description adds genuine business context beyond that: the platform fee is non-refundable on guest cancellation and refunded in full only when Dubai Table fails to secure the table, plus the fact that a relationship manager confirms via WhatsApp (an asynchronous human confirmation step). No contradiction with the destructive 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?

Three sentences, front-loaded with the action and its required inputs before the refund rule and the WhatsApp confirmation detail. Nothing is redundant, though the refund clause is dense and could be split for scanability.

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?

An output schema exists, so return values need not be explained, and the refund/confirmation flow is covered. What is missing for a destructive operation is whether the relationship-manager confirmation is required for the cancellation to take effect, any timing or deadline rules, and who is authorized to cancel. Those gaps matter for an irreversible action.

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%, so the description carries the burden for two undocumented parameters. "By reference and phone" does establish what each parameter is (booking reference, guest phone number), which is real added meaning. However, no format, normalization, or country-code expectation for phone is given, so the compensation is partial.

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 ("Cancel a request by reference and phone"), so the agent knows it is a cancellation keyed on two identifiers. It does not differentiate itself from the sibling cancel_checkout, which an agent could plausibly confuse with this tool. Minor noun drift between the tool name (booking) and the description (request) is tolerable but not clarifying.

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

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

No when-to-use guidance and no mention of cancel_checkout or any alternative for canceling other object types. The only usable hints are implicit (both ref and phone are required). The agent must infer when this tool applies rather than being told.

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

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

The annotations already flag destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds real value beyond that by disclosing the secondary effect: the unpaid table request is cancelled alongside the session, which the annotations cannot 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?

A single front-loaded sentence with the destructive side effect in parentheses. Every clause earns its place and nothing is padded.

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?

An output schema exists so return values needn't be explained, and annotations cover the destructive/idempotent profile. The only real gap is the undocumented 'id' and 'meta' parameters, which a caller must supply 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 0% across two parameters, including a nested 'meta' object with no documented structure and no statement of what 'id' refers to. The description adds no parameter meaning whatsoever, so it fails to compensate for the coverage gap.

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 ('Cancel a UCP checkout session') and adds meaningful scope by noting the associated unpaid table request is also cancelled. It implicitly separates itself from cancel_booking by naming the checkout-session object, though it doesn't explicitly contrast the siblings.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives like cancel_booking or update_checkout. The agent is left to infer the trigger condition entirely from the tool name.

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 read-only, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds behavioral context beyond annotations: results are computed live minus already-requested or confirmed tables, and each table includes zone, seats, and minimum spend in AED. This is helpful, though it doesn't mention rate limits, caching, or edge cases like fully booked venues.

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 that front-load the core purpose (what is returned) and then list filters and fields. No waste, well-structured, and easy 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?

With an output schema present, the description need not explain return values, and it still summarizes the fields carried by each table. It covers purpose, data source, and filters, but lacks explicit usage guidance against siblings and any edge-case behavior. Still quite complete given rich schema and 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 description coverage is 100%, so the schema already documents all five parameters in detail, including that party returns tables seating party..party+4 and that max_min_spend filters by AED. The description adds only a general filter summary, not syntax or examples beyond what the schema provides. Baseline 3 is appropriate when 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?

States a specific verb (Check) and resource (availability/table availability) and clarifies that results come from the live floor plan minus already-requested or confirmed tables, which distinguishes it from more static table-listing siblings. An agent can tell this is for real-time availability, not general venue info.

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 for checking free tables before booking, but doesn't explicitly state when to use this versus sibling tools like show_tables, request_table, or booking_status. It gives useful context (live floor plan, excludes already-requested tables) but no explicit when-not or alternative 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 only give a generic mutation profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description adds real substance: Stripe is charged, the session completes, and the no-instrument path returns requires_escalation with continue_url plus a concrete AED 49.50 fee. It still omits that the call is non-idempotent and that an idempotency-key should be supplied for a payment operation.

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 action and its side effect, and no filler. The second sentence is a long compound clause, but each detail (charge, escalation, fee) is load-bearing.

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 payment-completing mutation with nested parameters and 0% schema coverage, the description covers behavior well and an output schema exists so return values need not be detailed. However, the required id and idempotency-key are left entirely unaddressed, which is a meaningful gap for a non-idempotent charge operation.

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

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

Schema description coverage is 0% across three parameters, including nested objects, so the description must carry the load. It only loosely gestures at the payment parameter ('tokenised payment instrument') and says nothing about the required checkout id or the meta.idempotency-key field, leaving most parameters unexplained.

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

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

States a specific verb and resource ('Complete a UCP checkout') and goes on to say exactly what completing it does: places table requests with Dubai Table. That outcome-oriented framing separates it from create_checkout/update_checkout without needing to name them.

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

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

Describes the two operative conditions clearly (with vs without a tokenised payment instrument) and what each path yields, which tells the agent when the escalation branch applies. It never explicitly says when to prefer this over create_checkout or update_checkout, so it falls short of the 5 bar.

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 it as non-read-only, non-destructive, non-idempotent, and closed-world, so the safety profile is covered. The description adds real value beyond that: the lifecycle status values returned (incomplete | ready_for_complete | requires_escalation | completed | canceled) tell the agent this call yields an unfinished session rather than a confirmed booking.

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, front-loaded sentences with no padding; the purpose leads and the ID grammar and return statuses follow. The opening 'Universal Commerce Protocol checkout' is mild framing rather than actionable content but sets context cheaply.

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?

An output schema exists, so the return-value enumeration is arguably redundant but harmless. For a nested, mutation-flavored creation tool the description covers purpose, the key ID format, and resulting states adequately; the remaining gap is the absence of workflow/precondition guidance against its siblings.

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%, so the description must carry the load. It does document the single most important input contract — the line_items[].item.id grammar rz:<venue>:<table_id|zone:<Zone>|any>:<YYYY-MM-DD>:<party> — but leaves quantity, the buyer fields, and meta.idempotency-key entirely unexplained.

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

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

States a specific verb and resource: 'Creates a checkout session for one or more table requests,' with the UCP context named. An agent can distinguish it from get_checkout/cancel_checkout/complete_checkout/update_checkout by the verb alone, though no sibling is explicitly named and its relationship to request_table is unstated.

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

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

No when-to-use guidance is given, and no alternative is referenced. With siblings like request_table, create_checkout, and complete_checkout in the same flow, the agent gets no signal about which one starts the booking pipeline or what preconditions (venue availability, party size) must hold first.

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 this as a safe, idempotent, non-destructive read. The description adds useful context by naming the contact channels (WhatsApp or email), but reveals nothing further about response content, availability, or authentication. With annotations carrying the safety burden, a 3 is appropriate.

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 first sentence is front-loaded and useful. The trailing sentence about the concierge arranging tables across Dubai reads as promotional context that adds little decision value, so the description is slightly padded.

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 an output schema present, return-value details need not be described, and zero parameters mean no schema gaps. The description covers purpose and call conditions, leaving it essentially complete for a contact/escalation tool.

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

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

The tool takes zero parameters and the schema is trivially complete, so there is nothing for the description to compensate for. Baseline 4 applies.

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 outcome: reaching a relationship manager at Dubai Table via WhatsApp or email, and scopes it to cases 'outside these venues, large groups, or special arrangements.' This clearly separates it from the booking-oriented siblings like request_table and list_venues, though it doesn't name a specific sibling.

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

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

Gives explicit trigger conditions (large groups, special arrangements, anything outside the covered venues), which is clear escalation guidance. It stops short of naming the alternative tools or stating when NOT to use it, but the implied routing is understandable.

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 fully covered structurally. The description adds no behavioral context beyond that (e.g., not-found behavior, id format), but it does not contradict the annotations either.

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 filler. Efficient, though it is arguably under-specified rather than optimally concise.

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

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

An output schema exists, so return values need not be described, and the read-only annotations cover safety. However, given a nested meta parameter at 0% schema coverage and a terse description, the definition is only minimally adequate for an agent to invoke it correctly.

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

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

Schema description coverage is 0% with two parameters. The phrase 'by id' loosely maps to the required id, but the meta object parameter is entirely undocumented in both schema and description, so the description fails to compensate for the coverage gap.

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 (UCP checkout session) and scopes it to a lookup by id, which cleanly separates it from siblings like create_checkout, update_checkout, cancel_checkout, and complete_checkout. It stops short of naming any sibling or elaborating on what a 'UCP checkout session' is.

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 guidance on when to prefer this over alternatives such as booking_status or the other checkout tools, nor any stated prerequisites or context for retrieval. Usage is only implied by the name and verb.

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, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds genuine business context not in the annotations, notably the AED 49.50 platform service fee and the seat/minimum-spend ranges, but says nothing about freshness, pagination, or whether the catalog is cached.

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?

One colon-delimited sentence, front-loaded with scope ('Every room Dubai Table books across Dubai') followed by the payload inventory. It is dense but every clause describes an actual returned field, so little of it is waste.

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

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

For a zero-argument, read-only listing with an output schema present, the description covers the essentials; the output schema carries field shapes, and annotations carry the safety profile. The only real absence is discovery guidance, which is a usage concern rather than a completeness gap in what the tool is.

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; the baseline of 4 applies. No argument syntax is needed or missing.

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 concrete resource (every room Dubai Table books across Dubai) and enumerates the domain attributes the listing carries, which cleanly separates it from action-oriented siblings like request_table, show_tables, and cancel_booking. It never states the plain verb 'list' or 'returns', but the intent is unambiguous from the name plus the enumeration.

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 when-to-use statement, no prerequisites, and no mention of any alternative. An agent can infer this is a discovery/catalog call that likely precedes request_table or check_availability, but that inference is left entirely to the reader.

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 write/non-idempotent/non-destructive; the description goes much further, disclosing the AED 49.50 platform fee, the Stripe checkout opening, the deposit_url hand-off to the guest, and the WhatsApp alert plus relationship-manager confirmation. These are meaningful side effects an agent must know before invoking.

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 purpose and packs side effects, prerequisites, and routing guidance into three dense sentences with no filler. Slightly run-on, but every clause 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?

Covers the purpose, the required inputs, the checkout hand-off, and the fallback placement path; the output schema handles the return shape (deposit_url). Minor gaps remain in explaining secondary optional fields like notes, occasion, and 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?

With 71% schema coverage the schema documents most parameters, but the description adds the table_id-vs-zone decision logic and the requirement that phone include a country code, which is not spelled out everywhere in the schema. It omits context for notes, occasion, source, and email.

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 ('Place a real table request with Dubai Table') and enumerates the concrete side effects: booking record, Stripe fee checkout, and WhatsApp alert to the relationship manager. This clearly distinguishes it from sibling lookup tools like check_availability and mutation tools like cancel_booking.

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 the agent to check_availability for an exact table_id, or a zone, or neither to let the relationship manager place the party. It also states the required guest name/mobile prerequisites, though it does not say when to prefer cancel_booking or booking_status instead of a fresh request.

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, closed-world), so the description's real contribution is the host-environment dependency (needs a UI-capable host) and the fact that the rendered view embeds a request form and a payment button, which implies side effects are surfaced here via sibling tools. It stops short of saying what happens on a non-UI host or whether the embedded form/payment button itself mutates state, which is the one ambiguity given readOnlyHint=true.

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 action, then the sibling comparison, then the routing preference. No filler and no repetition of 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 an output schema present, the description doesn't need to explain return values, and it does cover the host requirement and tool-selection rule well. The remaining gap is the three undocumented parameters, which leaves an agent guessing about filtering inputs for a picker 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?

Only 2 of 5 parameters (date, venue) carry schema descriptions, so coverage is 40% and the description compensates with nothing — zone, party, and max_min_spend are undocumented in both places. The description does hint that "venue" may accept an event name, but that detail already lives in the schema, so no net additive value for parameters.

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

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

Specific verb ("Render") plus specific resource ("the interactive table picker for a venue and night") and a scope qualifier (ChatGPT / MCP Apps hosts). It also distinguishes itself from the sibling tool by noting it carries the same data as check_availability, so an agent can differentiate the two 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?

Explicit routing rule: "Prefer this over check_availability when the host can display UI." That names the alternative and the deciding condition, which is exactly what an agent needs to choose between two highly overlapping tools.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=false, so safety and side-effect profile are largely covered by structured data. The description adds one genuinely useful behavioral fact — that updates REPLACE rather than merge the affected fields. With non-annotated details like what happens to omitted fields or auth requirements absent, a 3 is appropriate.

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 filler; the mutation scope comes first. It is efficient, though it is arguably too terse given the complexity of the payload rather than wasteful.

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 mutation tool over a nested checkout object with 0% schema documentation and no parameter descriptions, the description is thin. The output schema removes any need to explain return values, but the description still fails to describe the checkout payload structure, partial-update semantics, or required session state.

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% across three parameters including a nested 'checkout' object, so the description carries the full burden. It partially compensates by naming two plausible sub-fields (line_items, buyer) inside checkout, but leaves 'id' and 'meta' entirely undocumented and gives no shape or format for the checkout payload.

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

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

Uses a specific verb ('Replace') and names the exact resources affected ('line_items and/or buyer on a UCP checkout session'), which is far more precise than the sibling names alone would suggest. It is not explicitly differentiated from create_checkout/get_checkout/cancel_checkout/complete_checkout, but the mutation scope is clear enough to route correctly.

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 states what is changed but never says when to reach for this tool versus create_checkout, get_checkout, or complete_checkout. There is no mention of prerequisites (e.g., an existing session id) or a state in which the checkout must be before updating. An agent must infer all usage context.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds the Dubai timezone frame and the 7/14-day default and cap, but says nothing about auth needs, rate limits, or what an empty result means. Useful but modest added context.

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

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

A single dense sentence with the core concept front-loaded and constraints trailing in a parenthetical. Nothing is wasted, though the stacked em-dashes and parenthetical make it slightly harder to parse than a clean two-clause sentence.

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?

An output schema exists, so return values need no explanation, and there are only two simple optional parameters. The description supplies the window semantics, defaults, and maximum an agent needs to call it correctly.

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

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

Schema coverage is 50% — 'date' is documented but 'days' carries only type/default/min/max with no prose. The description restates the defaults and cap ('default today in Dubai, 7 days, max 14'), which mirrors rather than enriches the schema, so it lands at the baseline for partial 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?

States a specific resource — the night-by-night programme of Dubai Table signature nights and venue nights — with a clear time scope, so an agent can tell it is a discovery/listing tool. It does not explicitly contrast with siblings like list_venues or check_availability, but the content domain is distinct enough to be unambiguous.

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

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

The description gives a window definition ('next N days from a date') but no when-to-use guidance, no exclusions, and no named alternative. An agent browsing for events vs. checking availability or listing venues gets no routing help from the text.

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