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

No annotations are provided, so the description carries full burden. It does not disclose idempotency, error behavior for duplicates, authentication needs, or side effects. Only states the basic 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?

The description is a single sentence, which is concise. However, it is too sparse to be maximally helpful, lacking details that could be included without losing conciseness.

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 add operation, the description minimally covers the purpose. But without output schema or behavioral details, it is incomplete for an agent to invoke correctly, especially regarding duplicates or success confirmation.

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 should compensate. However, it adds no meaning beyond the schema's 'restaurant_id' parameter, which is already defined as an integer with constraints.

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 'Add a restaurant to the user's Saved Restaurants list' clearly states the action (add) and the resource (restaurant to Saved Restaurants list). It distinguishes itself from siblings like 'opentable_remove_favorite'.

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

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

No explicit guidance on when to use or alternatives. Usage is implied by the name, but no when-not or context is provided.

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

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

No annotations exist, so the description carries full burden. It discloses token expiry, dry-run mode, CC-required slot behavior, auto-fetching of user profile, return values, and limitations like database_region not being auto-derived.

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 long but well-structured, front-loaded with the main action, and each sentence adds useful information. Slightly verbose but not unnecessarily.

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 12 parameters and no output schema, the description is fully adequate, covering prerequisites, side effects, return values, error conditions, and alternatives.

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% (high), baseline 3. The description adds significant value by explaining token expiry, optionality of dining_area_id, dry-run with confirm, booking_token requirement, and database_region limitation.

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

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

The description clearly states 'Book an OpenTable reservation' and distinguishes from siblings by specifying prerequisites (slot_hash, reservation_token from opentable_find_slots) and noting that Listing-type restaurants should use alternative flows.

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

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

The description provides explicit guidance on when to use this tool, including token expiry, optional parameters, required preview step for CC-required slots, dry-run behavior, and conditions for Listing-type restaurants. It also references sibling 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 declare readOnlyHint=true, and the description confirms read-only preview behavior. It adds timing context (holds slot ~60-90s) and notes skipping redundant re-lock in book, going beyond 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-loaded with main purpose, all sentences add value (purpose, required scenarios, alternatives, timing, edge cases). No redundancy despite length.

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 all critical context: what it surfaces, when mandatory, special cases (Listing, Experience-mandatory), timing, and database region handling. Adequate given no output schema.

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

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

Schema coverage is 80%, so baseline is 3. The description adds extra context for experience_id, database_region (with limitation), and auto-resolve for dining_area_id, justifying above baseline.

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

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

The description clearly states it previews a booking before committing, distinguishes from sibling opentable_book, and specifies the resources surfaced (cancellation policy, payment card, booking_token).

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 says when to use (required for CC-required slots, safe for standard slots) and when not (Listing-type restaurants cannot fetch slot; check bookable first). Also provides guidance for Experience-mandatory slots.

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

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

With no annotations, the description fully explains the dry-run behavior (no action without confirm:true) and the prerequisites. It does not cover all potential behaviors (e.g., error handling, reversibility), but the key behavioral trait is disclosed.

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

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

Two sentences, front-loaded with purpose, no unnecessary words. Every sentence adds essential information.

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

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

The description covers the required workflow but omits return value information and does not discuss edge cases or error handling. The database_region parameter is important but not mentioned in the description, although it is in 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?

The description adds meaning for three parameters (restaurant_id, confirmation_number, security_token) by noting their source. It does not mention the database_region parameter, which is well-described in the schema. Overall, it partially compensates for the 40% schema coverage.

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

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

The description clearly states 'Cancel an OpenTable reservation,' using a specific verb and resource. The action is unambiguous and distinct from sibling tools like opentable_book or opentable_modify.

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 to obtain required parameters (from opentable_list_reservations or opentable_book) and explains the dry-run vs. cancellation workflow. However, it does not explicitly contrast with opentable_modify (for changes instead of cancellation).

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 say read-only. The description adds that availability is not held, that tokens must be used promptly, that dining-area resolution is automatic, and that a one-time page load may be needed. This is genuinely useful behavioral context beyond the structured metadata.

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?

Dense but efficient. Every sentence adds operational value: core behavior, next step, response field, cross-tool handoff, and an error prerequisite. 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?

Given this is a multi-step integration tool with no output schema, the description covers inputs, outputs, handoff to booking, and an error prerequisite. Minor gap: no statement about empty availability responses.

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

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

The schema covers the parameters, and the description adds cross-tool semantics: which parameter is the anchor, what the response token is for, and that view=dining_area changes the response shape. It doesn't restate every schema description, which is appropriate.

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

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

Opens with a precise action and object: 'Given a restaurant_id, list available reservation slots for a date and time.' It also separates listing from booking, which distinguishes it from the booking 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?

Clearly says this tool only lists slots and that booking happens via another tool, including the token handoff. It doesn't explicitly enumerate when not to use it, but the placement and warning are strong enough for an agent to route correctly.

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

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

With readOnlyHint already true, the description still adds value by explicitly stating that payment and credit-card details are never exposed, and by revealing that the tool operates on the authenticated user's data. It also names the returned field categories, supplying more than the annotation alone. No behavior contradicts the 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?

Two sentences with no waste: the first lists the resource and returned fields, the second covers an important guarantee in the front-loaded core. It is compact, structured, and enough for an agent to parse quickly.

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 profile endpoint with one optional fully-specified parameter, the description together with the schema and annotations is sufficient: it gives the resource, lists the returned content, and notes the privacy boundary. Omitting field-level types or output formatting is not a significant gap because no output schema is 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 description coverage is 100%, and the schema's own text fully explains the 'view' parameter (compact vs. full, default behavior, what compact strips). The tool description does not mention the parameter, so it adds no semantic information beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource ('Get the authenticated OpenTable user's profile') and enumerates exactly what data is included (name, email, phones, loyalty points and tier, home metro, member-since date). It is easy to distinguish from sibling tools like opentable_list_reservations or opentable_search_restaurants, which target different resources.

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 purpose clearly implies when to use the tool—when the caller needs the authenticated user's profile rather than reservations, favorites, or booking operations. It does not name an alternative or present explicit when-not conditions, but the 'never exposed' note about payment details does carve out an expectation boundary. The context is clear even though it lacks direct sibling routing.

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=true, which the description matches (a 'Get' operation). Beyond that, the description discloses genuinely useful behavior: the availability_token is for internal booking use, and the tool resolves both /r/{slug} and legacy /{slug} URLs. No contradiction with 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?

Two sentences, purpose and field list front-loaded, with input-format details in the second sentence. Dense but not bloated; the long field enumeration earns its place given there is no output schema to describe the return shape.

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

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

For a read tool with no output schema, the description compensates by listing the returned fields and clarifying the union-typed identifier parameter's resolution behavior. The view parameter's semantics are fully handled by the schema. Little an agent needs 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?

Schema coverage is 100% and both parameters (view, restaurant_id) are already documented in detail within the schema, including the enum and the anyOf union. The description adds only a marginal guarantee ('passing the search result's url verbatim always resolves'), which is not in the schema but is a small increment over a solid baseline.

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 ('Get full details for a single OpenTable restaurant') followed by an explicit field list (cuisine, price band, address, hours, phone, etc.) that distinguishes it from siblings like opentable_search_restaurants (search) and opentable_get_profile (user profile). The availability_token mention adds precision about what is returned.

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?

Clearly identifies where valid inputs come from (opentable_search_restaurants, opentable_list_reservations, opentable_list_favorites) and gives practical guidance on passing the search result's 'url' verbatim to guarantee resolution. It does not explicitly contrast against alternatives ('use this when... not that when...'), but the input-source guidance is strong enough to route an agent correctly.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description reinforces safety with 'Read-only, no auth required' and adds crucial behavioral context: it reveals the exact diagnostics returned (role, port, version, extension link state, elapsed time, and a distinguishing hint). This goes beyond the annotations by disclosing what the call exercises and how the output isolates failures, without any contradiction.

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 front-loaded with the action, then lists the returned diagnostics in a compact, en-dash-separated series. The final two sentences tersely state 'Read-only, no auth required' and give a one-line invocation condition. Every phrase carries diagnostic value; none is fluff. Despite its length, it remains structured and readable.

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 a zero-parameter, read-only, idempotent health check with no output schema, the description provides complete context: it describes the jest performed, the specific fields returned, and the interpretation hints. The agent will know exactly what it is calling, what output to expect, and when the call is appropriate. Nothing critical 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?

The tool has zero parameters, so the input schema is trivially complete (describe coverage is 100%). The description adds no parameter semantics because none are needed. Per rubric, 0 params earns a baseline of 4, and there is no gap to compensate.

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

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

The description uses a specific, action-oriented phrase: 'Round-trips a small public www.opentable.com URL (/robots.txt) through the fetchproxy bridge and returns diagnostics.' It names the resource, the operation, and explicitly enumerates the diagnostic fields. This clearly distinguishes it from the sibling tools, which are all business operations (book, cancel, search, etc.) rather than a bridge health check.

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 exactly when to call it: 'Call this when a real tool fails and you want to know which hop broke.' This is an explicit trigger condition. It also implies when not to use it (for normal data operations), and since none of the siblings are diagnostic tools, no alternatives need be named. The guidance is direct and actionable.

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, and the description does not contradict that. It adds useful context that the source is the user's Saved Restaurants list and enumerates the returned fields, but it does not disclose pagination, limits, or other behavioral details. No contradictions with 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?

One sentence with no fluff, front-loaded with verb and resource, then a compact list of returned fields. Every clause earns its place, and nothing is repeated from the schema.

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 with a single optional parameter and no output schema, the description covers scope and return fields well. It lacks details like pagination, response ordering, or explicit auth requirements, but those are secondary for selecting and invoking a favorite-list tool.

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

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

The input schema already covers the only parameter ('view') with a full description and enum, so the prose description doesn't need to add parameter meaning. The schema's coverage is 100%, so the baseline of 3 applies; the description doesn't make the one parameter any clearer, but it doesn't need to.

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 ('the user's saved restaurants from OpenTable'), and enumerates the returned fields. The phrase 'Saved Restaurants list' clearly targets favorites, but it doesn't explicitly compare against siblings like opentable_list_reservations or opentable_search_restaurants, so sibling differentiation is implicit rather than stated.

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

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

No guidance about when to use this tool versus add_favorite/remove_favorite or search_restaurants. No prerequisites, exclusions, or non-goals are stated, so the agent must rely on the tool's name and inference to know when it fits.

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=true, and the description adds the detail that each entry includes a security_token needed for cancel/modify, which is useful. It does not disclose pagination, limits, or error behaviors, but the safety profile is covered by annotations and the core data shape is hinted.

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 concise and front-loads the core purpose and default behavior. It adds key details about scope and the security_token in just two sentences. The schema's 'view' description is verbose but belongs to the schema, not the description.

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

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

Given the tool's simple read-only nature, the description covers the essential context: what is returned (reservations, including security_token) and how to control scope. No output schema exists, so the return format is hinted but not exhaustive; however, for a list operation this is acceptable.

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%, and the description adds meaning to 'scope' by explaining its values and default. The 'view' parameter is fully documented in the schema, so the description doesn't need to add more. This compensates well for the uncovered parameter.

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

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

The description clearly identifies the action (list), the resource (the authenticated user's OpenTable reservations), and explicitly differentiates from siblings such as opentable_search_restaurants or opentable_get_profile. It does not name a direct sibling for listing other entities, but the scope is unambiguous.

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

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

The description explains the default behavior (upcoming) and instructs how to broaden with scope, providing clear usage guidance. It does not explicitly state when not to use this tool relative to siblings, but the context is sufficient for typical listing scenarios.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses that without confirm:true the tool is a dry-run, that confirmation_number is preserved, that reservation_id and security_token may be regenerated, and that mismatched dining_area_id is refused. It also states the return shape (same as opentable_book plus was_modified: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?

The description is dense but every sentence earns its place: prerequisites, side effects, optional parameters, return shape, and dry-run flow are all covered without fluff. The structure front-loads the mandatory identity and preview requirement before optional details, which is appropriate for a complex mutation tool.

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

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

Given no annotations and no output schema, the description is notably complete: it specifies return shape via opentable_book plus was_modified, explains the reservation-identity and confirmation flow, warns about Listing-type restaurants, and describes the dry-run-to-confirm invocation protocol. An agent has everything needed to invoke this tool correctly.

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

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

Schema coverage is 67%, so the description must add meaning, and it does: it identifies restaurant_id + confirmation_number + security_token as the reservation identity, marks modify_token as mandatory and sourced from opentable_modify_preview, and explains that dining_area_id and experience_id are optional/tamper-check values. It also ties reservation_token and slot_hash to opentable_find_slots, adding provenance 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?

The description states 'Modify an existing OpenTable reservation in place' with a specific verb and resource, and clearly distinguishes this from sibling tools like opentable_book (new reservations) and opentable_modify_preview (required preview step). It also names the endpoint and core semantics, so an agent can understand exactly what this tool does.

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

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

The description explicitly requires a fresh modify_token from opentable_modify_preview and explains why the preview is mandatory. It also tells agents to check opentable_get_restaurant.bookable for Listing-type restaurants and to re-run with confirm:true to submit, including the dry-run behavior. This is clear when-to-use and when-not-to-use guidance.

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

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

Beyond readOnlyHint=true, the description discloses that the endpoint returns cancellation_policy, CC re-hold details, and modify_token; that dining_area_id is auto-resolved when omitted; and that Listing-type restaurants cannot proceed. It also reveals the internal mechanism (isModify=true in the /booking/details URL), giving the agent useful expectations about 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?

The description is dense but front-loaded: the first sentence states the purpose, and every subsequent sentence earns its place by covering source data, return values, a required precondition, and a failure mode. There is no filler or redundant restatement of schema descriptions.

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 12-parameter, 8-required tool with no output schema, the description supplies the full call context: where identity and slot args come from, what the response contains, the mandatory position before opentable_modify, and the Listing-type failure condition. This is sufficient for an agent to invoke the tool correctly.

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

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

Schema coverage is 67%, and the description compensates by explaining the provenance of key parameters: restaurant_id + confirmation_number + security_token come from list/book results; reservation_token and slot_hash come from a fresh find_slots call. It clarifies optionality and auto-resolution of dining_area_id and the relationship between experience_ids and experience_id, mapping cleanly to the schema fields.

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

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

The description opens with 'Preview a MODIFICATION to an existing OpenTable reservation' — a specific verb, resource, and scope. It distinguishes itself from opentable_book_preview by noting it 'Mirrors opentable_book_preview' but targets the modify state and returns a modify_token, so an agent can tell them apart.

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 states 'REQUIRED before opentable_modify — no shortcut path,' explicitly setting when this tool must be used. It directs the agent to source identity from opentable_list_reservations or the original opentable_book result, to pull NEW slot args from a fresh opentable_find_slots call, and it names the Listing-type exclusion with a check on opentable_get_restaurant.bookable.

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

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

No annotations provided, so the description carries full burden. It indicates a mutation (remove), but fails to disclose important behavioral traits such as whether the operation fails if the restaurant is not a favorite, authentication requirements, or rate limits. Transparency is minimal.

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

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

The description is a single concise sentence of 11 words, front-loading the action and resource with no extraneous information. It is efficient and fits within the MCP context.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description provides a basic functional understanding. However, it lacks guidance on usage and behavioral details that would make it fully complete for agent usage.

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 parameter. While the parameter name 'restaurant_id' is self-explanatory, the description adds no additional meaning or context (e.g., where to find the ID, or acceptable formats). The tool description does not compensate for the lack of schema documentation.

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

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

The description clearly states the action ('Remove') and the resource ('a restaurant from the user's Saved Restaurants list'). It effectively distinguishes from sibling tools like opentable_add_favorite and opentable_list_favorites.

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 the tool is used when a restaurant should be removed from favorites, but it does not provide explicit guidance on prerequisites (e.g., the restaurant must already be a favorite) or when to avoid using it. Sibling tool names provide context, but the description itself lacks explicit usage direction.

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

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

The read-only hint is already in annotations, so the description carries little weight on that front. The description adds useful behavioral context beyond the schema: it lists what the response contains and, more importantly, declares that it does NOT include bookable slot tokens. This influences whether the agent should continue with this tool or switch to the slots tool. It does not cover pagination or rate limits, but those are not hinted as critical.

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: one defines the purpose, one defines the output and the critical limitation. There is no filler, and the sibling disambiguation is also the back-loaded second sentence. This is efficient and 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 search tool with no required parameters and no output schema, the description covers the gaps: it lists the returned fields and warns about the absence of the slot tokens. The input schema already handles the parameter details. The additional behavioral note about the partial output is exactly the kind of information the description needs to provide.

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

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

The input schema already uses many parameters (7 of 9) with verbose descriptions, which covers most semantics. The description itself does not elaborate on any parameter, so its added value here is minimal. Latitude and longitude are left without a schema description, and the tool description does not compensate for those either, but the high overall coverage keeps this acceptable at the baseline.

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

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

The description opens with a specific verb and resource ('Search OpenTable for restaurants'), names the return fields (cuisine, neighborhood, price band, rating, description, URL), and distinguishes the tool from the sibling `opentable_find_slots` by stating it explicitly does not include bookable slot tokens. That is enough for an agent to tell this from its 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 a clear when-not: this tool does NOT include slot tokens, and then names the exact sibling to use instead (`opentable_find_slots`) for availability checks. This is an explicit exclusion and alternative, which meets the top bar.

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