gondola

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

Annotations indicate mutation (destructiveHint=true) and open world. Description adds details on booking process, override behavior for loyalty_account_id, and error messages. 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?

Well-structured: purpose first, then prerequisites, then parameter details with Args section, and Returns note. Slightly verbose but necessary given 9 parameters and multiple integration points.

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 parameters and their sources. Explains interaction between travel_profile_id, loyalty_account_id, and guest fields. Mentions output format. Adequate for a complex mutation tool with 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 0%, but description extensively explains each parameter's purpose and origin (e.g., gondola_rate_id from get_hotel_details, loyalty_account_id from get_loyalty_accounts). Compensates fully for lack of schema descriptions.

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?

Description clearly states it books a hotel room using a rate from get_hotel_details. Verb (book), resource (hotel room), and source are specific. Distinguishes from sibling tool book_vehicle which books a different resource.

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

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

Provides clear prerequisites: requires Gondola account, payment method, and rate ID from get_hotel_details. Explains when to use travel profiles and loyalty accounts. Does not explicitly state when not to use or alternatives, but implicit from sibling tool names.

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 indicate destructiveHint=true (mutating). The description adds that it returns confirmation or error, but does not disclose idempotency, rate limits, or cancellation policy. Adequate but minimal extra 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?

The description is well-structured with a clear purpose sentence, prerequisites, and a bulleted args list. Could be slightly more concise, but each sentence adds value. Front-loaded effectively.

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 11 parameters (9 required), an output schema explaining return values, and all parameters documented in description, the tool definition is complete. No critical missing information like error handling or side effects beyond acknowledgment.

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 carries full burden. It explains every parameter meaning, including examples (e.g., vendor_code 'ZE'), format (phone_number), and source (payment_id from get_payment_methods). Adds significant value beyond schema names.

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 a rental vehicle from a search result', using a specific verb and resource. It distinguishes from sibling tools like 'book_hotel' by explicitly focusing on vehicles.

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

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

The description explicitly states prerequisites (Gondola account, payment method) and references get_payment_methods to find the payment ID. It implies usage after search_vehicles. Lacks explicit alternatives or when-not-to-use, but clear 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 indicate destructiveHint=true and readOnlyHint=false. The description adds 'Cancel' and mentions a return value, but does not disclose additional behavioral traits such as whether cancellation is reversible, if fees apply, or if the booking must be in a cancellable state.

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 with a clear docstring structure (Args, Returns). Every sentence provides necessary information without 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?

Given the tool's simplicity (single parameter, destructive action, output schema exists), the description adequately covers purpose, parameter meaning, and return type. It could mention potential side effects or conditions, but overall it is sufficiently complete.

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

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

The schema has 0% coverage, but the description includes an Args section that explains the booking_id parameter as 'The Gondola booking ID (confirmation number)'. This adds meaningful context beyond the schema's type and title, compensating well for the low coverage.

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

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

The description clearly states the action ('Cancel') and the resource ('existing vehicle booking'). It distinguishes this tool from siblings like 'book_vehicle' (creation) and 'get_vehicle_booking' (retrieval).

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or conditions for cancellation. It simply states what the tool does.

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 destructiveHint=false. The description adds value by detailing the return format (cash rate, points rate, CPP, value signals, recommendations) and usage context, but doesn't disclose additional behavioral traits like auth needs or rate limits.

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

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

Concise and well-structured: purpose upfront, usage guidance, parameter details, and return info. No unnecessary sentences.

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 output schema exists, the description adequately covers returns. All 4 parameters are explained, and the tool's role in the workflow (post search_hotels) is clear. Siblings like search_hotels and book_hotel are distinct.

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%, but the description includes an 'Args' section explaining each parameter: hotel_ids (max 5, from search_hotels), checkin/checkout (format YYYY-MM-DD), num_adults (default 2). This adds significant meaning beyond the bare schema.

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

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

The description clearly states 'Compare cash vs points rates across multiple hotels side-by-side,' specifying the verb (compare), resources (rates), and output format (comparison table). It distinguishes from siblings like search_hotels and book_hotel.

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 'Use this after search_hotels to help a user decide between their top hotel picks,' providing clear context. No explicit exclusions, but the intended use case is well-defined.

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 indicate readOnlyHint=false and destructiveHint=false, so the description adds context about email notification and the account requirement. It does not describe any destructive side effects beyond creation, but provides sufficient transparency for a non-destructive write 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 concise and well-structured with separate sections for purpose, usage, arguments, and returns. Every sentence adds value without 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?

Given the tool's moderate complexity (3 parameters, 1 required), the description covers purpose, parameter semantics, prerequisites, and return value. The existence of an output schema reduces the need to detail return values, making the description complete.

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

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

With 0% schema description coverage, the description fully compensates by explaining all parameters: hotel_id (Vervotech property ID), checkin/checkout (format and constraint). This adds significant meaning beyond the schema types.

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

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

The description clearly states the tool creates a rate alert to monitor hotels for price drops. It specifies the verb 'create' and resource 'rate alert', and distinguishes from siblings like delete_rate_alert and get_rate_alerts.

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 when to use the tool (to monitor price drops) and prerequisites (requires Gondola account with API key). It mentions optional date parameters but does not explicitly state when not to use or suggest alternatives like book_hotel.

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. Description adds that the tool returns coverage type, max days, and summary, and that it performs a lookup. No contradictions, and the return structure is disclosed.

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

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

The description is succinct with no filler, clearly structured with Args and Returns, and front-loaded with the core purpose.

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 presence of an output schema, the description sufficiently covers parameter usage and return fields. No gaps remain for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 0%, but the description explains the two mutually exclusive parameter groups and that card_provider is required with card_number_bin, adding crucial meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Look up') and resource ('rental car CDW/LDW coverage'), and distinguishes this tool from siblings like booking or vehicle 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?

Explicitly provides two alternative parameter combinations ('EITHER credit_card_product_name OR card_number_bin + card_provider'), guiding the agent on valid inputs. Does not mention when not to use it, but the clarity is high.

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 mark this as destructive. The description confirms the mutation ('Delete') and adds auth requirements, providing useful behavioral context beyond annotations. It does not mention permanence, but that's minor.

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 with clear sections (Args, Returns). Every sentence serves a purpose, no fluff. Perfectly sized for a simple 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?

For a one-parameter destructive tool with an output schema, the description covers the action, parameter, return value, and auth requirement. No gaps given the low complexity.

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

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

Despite 0% schema description coverage, the description explains the single parameter 'alert_id' by noting its source ('from get_rate_alerts'), adding meaning beyond the schema type.

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

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

The description clearly states the verb 'Delete' and the resource 'rate alert', explicitly linking it to the purpose of stopping price monitoring. This distinguishes it from siblings like create_rate_alert and get_rate_alerts.

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 includes a prerequisite (Gondola account with API key) and implies usage when an alert is no longer needed. However, it does not explicitly state when not to use it or compare it to alternatives, though context from siblings makes it 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 indicate readOnlyHint=true and destructiveHint=false, so the description adds value by clarifying that it 'shows per-supplier status and a full breakdown of every rate by type.' This goes 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?

The description is concise and well-structured: a one-sentence purpose, a usage guideline sentence, and a parameter list. Every sentence adds value with no 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?

Given the presence of an output schema (not shown), the description does not need to detail return values. It covers input parameters thoroughly. However, a brief note about the output structure could slightly improve completeness.

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%, but the description fully documents every parameter with clear semantics: hotel_id as 'Vervotech property ID', checkin/checkout formats, num_adults defaults, and rate_sources as optional comma-separated values. This fully compensates for missing schema descriptions.

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

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

The description clearly states the tool's purpose: 'Diagnose rate availability and source statuses for a specific hotel.' It uses a specific verb ('diagnose') and resource ('rates'), and distinguishes itself from sibling tools like 'compare_rates' or 'book_hotel' by focusing on investigation of rate 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?

The description explicitly says 'Use this to investigate why certain rates ... are or aren't showing,' providing clear context for when to use the tool. While it doesn't explicitly state when not to use it, the purpose is well differentiated from 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=true and destructiveHint=false. The description's 'Get details' aligns but adds no behavioral info beyond that, such as rate limits or auth needs. It doesn't contradict annotations.

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

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

The description is extremely concise with a clear title, an 'Args' section, and a 'Returns' section. Every sentence is necessary and front-loaded, with no fluff.

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 tool with one parameter and an output schema, the description covers purpose, parameter semantics, and return content (hotel, dates, room, rate, status). It could mention error conditions or auth, but overall it is sufficiently complete.

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

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

With 0% schema description coverage, the description's 'Args' section explains that booking_id is 'The booking ID or confirmation number,' adding meaningful context beyond the schema's bare parameter name and type.

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 'Get details for a specific hotel booking' with a specific verb ('Get') and resource ('booking details'). It distinguishes from sibling tools like 'book_hotel' (creation) and 'get_vehicle_booking' (different resource).

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

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

The description implies usage when you have a booking ID to retrieve details, but it does not explicitly state when not to use this tool or recommend alternatives. No exclusions or context about when other sibling tools would be more appropriate.

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?

Describes behavior beyond annotations: two booking paths, auth-dependent outcomes, and anonymous user handling. Annotations indicate read-only and non-destructive, which the description aligns with. Adds valuable context about card eligibility.

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?

Well-structured with clear sections (overview, usage, args, returns). Slightly lengthy but every sentence adds value. Front-loaded with the core purpose.

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 annotations cover safety and output schema exists, the description is thorough: covers both booking paths, auth scenarios, anonymous user flow, and rate ID option. Leaves no gaps for typical 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 has 0% coverage, but the description provides detailed explanations for all six parameters, including format (YYYY-MM-DD), default values, and semantics (e.g., hotel_id from search_hotels, gondola_rate_id for deep-linking). Fully compensates for the schema 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?

Clearly states it gets booking options for a hotel and elaborates on two explicit booking paths, distinguishing it from sibling tools like book_hotel which actually completes the 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 advises to use after search_hotels or get_hotel_details when user wants to book, and to pass gondola_rate_id when a specific rate has been surfaced. Lacks explicit when-not-to-use guidance but context strongly implies 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 mark it as read-only. Description adds value by stating the authentication requirement (Gondola account) and the return format (formatted list or instructions to connect), which are not in 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?

Description is concise with four clear sentences. Each sentence serves a purpose: purpose, return content, auth requirement, return type. No unnecessary words.

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

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

Given zero parameters and an existing output schema, the description fully covers the tool's behavior: what it retrieves, authentication needs, and return format. No 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?

No parameters exist, so baseline is 4. Description does not need to add meaning beyond the schema, but it mentions 'across loyalty programs' which adds no further 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?

Description clearly states the tool retrieves free night certificates across loyalty programs, using a specific verb and resource. It distinguishes from sibling tools like get_loyalty_accounts which focus on general account details.

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 prefer this over siblings, nor any exclusions. Context implies it's for certificate-specific queries, but does not compare to alternatives like get_loyalty_accounts.

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 destructiveHint=false, so the description's task is lighter. The description adds context by stating it returns room options, pricing, cancellation policies, and amenities. It does not contradict annotations and provides useful behavioral details about the return content.

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 well-structured: a brief intro sentence, a usage recommendation sentence, then separate 'Args' and 'Returns' sections. Every sentence adds value, and the most important information is front-loaded. No wasted words.

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

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

Given the moderate complexity (4 params, output schema exists but not shown in detail), the description covers all necessary aspects: what the tool does, when to use it, parameter explanations, and a summary of return values. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, meaning the input schema properties have no descriptions. The description compensates fully by explaining each parameter in the 'Args' section: hotel_id is the Vervotech property ID from search_hotels, checkin/checkout format is YYYY-MM-DD, and num_adults defaults to 2. This adds significant meaning beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Get detailed information, room types, and rates for a specific hotel.' It uses a specific verb ('Get') and resource ('detailed information, room types, and rates') and distinguishes from siblings like search_hotels (which lists hotels) and book_hotel (which books).

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 says 'Use this after search_hotels to get full details for a hotel the user is interested in.' This provides clear usage context. While it doesn't explicitly state when not to use it or list alternatives, the guidance is sufficient for an agent to understand the workflow.

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, destructiveHint=false. The description adds value by specifying the tool returns up to 10 recent reviews with ratings and comments, which is not in the annotations. No contradictions.

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, with clear sections for use case and parameters/returns. Every sentence adds necessary information without 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 simple tool with one parameter and an output schema, the description sufficiently covers what the tool does and what it returns. It's complete enough for an agent to select and invoke 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?

The single required parameter hotel_id is described as 'The hotel's Vervotech property ID (from search results),' which clarifies its source beyond the schema's type alone. This compensates for the 0% schema description coverage.

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

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

The description clearly states the tool retrieves guest reviews for a specific hotel, distinguishing it from sibling tools like get_hotel_details or get_hotel_stats. It specifies the output type (recent reviews with ratings and comments) and a limit of 10.

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 says to use when helping users understand other guests' opinions, providing clear context. However, it does not mention when not to use it or suggest alternatives, which is acceptable given the tool's specific purpose.

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 indicate read-only, non-destructive behavior. The description adds useful behavioral context (historical comparison, percentile rankings) beyond the annotations, but lacks details on data recency or pagination.

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

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

Extremely concise and well-structured: purpose sentence, usage sentence, then labeled Args/Returns sections. No wasted words, and key information is 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?

Covers purpose, parameters, and return concept; output schema handles details. Slightly vague on 'chain' context and historical time window, but overall sufficient for an informed tool selection.

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 0% schema coverage, the description fully compensates by describing all four parameters in plain language, including the optional nature of nightly_points_cost and example currency values.

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?

Description clearly states the tool retrieves 'pricing analytics and percentile data' and helps determine if a rate is a good deal. It distinguishes from siblings like 'compare_rates' and 'predict_price' by focusing on historical percentile comparison.

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 'Use this to help users understand if a rate is a good deal,' providing clear context. However, it does not explicitly mention when not to use or name alternative 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 already indicate readOnlyHint=true, so the description's addition of return format (formatted list) and conditional behavior (instructions to connect if no accounts) adds useful context. It does not disclose any potential side effects or authorization nuances beyond the API key requirement.

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 with four short sentences, each serving a purpose. It could be slightly more front-loaded, but the first sentence clearly conveys the main action. No unnecessary 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?

Given zero parameters and the existence of an output schema, the description adequately explains the return value and conditional behavior. It addresses the key aspect of what the tool returns and under what circumstances, making it complete for a simple 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?

There are zero parameters, so the schema coverage is 100%. The description adds no parameter details, but baseline for 0 params is 4. No additional meaning is needed beyond what the schema provides.

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

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

The description clearly states that the tool retrieves hotel and airline loyalty accounts with points balances and values, using a specific verb and resource. It distinguishes itself from sibling tools like get_traveler_context and optimize_loyalty_portfolio by focusing on loyalty account details.

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 mentions a prerequisite (Gondola account/API key) but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. Usage context is implied but not directly addressed.

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 indicate readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read operation. The description adds useful behavioral context by specifying that it 'shows cash rates, points rates, and value percentiles,' which goes beyond annotations. No contradictions.

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 very concise (about 5 lines excluding Args) and well-structured: a summary sentence, usage guidance, then an Args section. Every sentence adds value, and the key info is front-loaded. No wasted words.

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

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

Given the tool's moderate complexity (rate calendar with multiple metrics), the description is complete. It explains what the calendar shows (cash, points, percentiles) and all parameters. An output schema exists, so the return format is documented elsewhere. No missing information for effective use.

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

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

The input schema has 0% description coverage, so the description fully carries the burden. It provides clear, helpful explanations for each parameter: hotel_id source, date format for start_date/end_date, and nights default. This adds significant meaning beyond the schema's basic type and title.

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 'Get a rate calendar showing prices across a date range for a hotel.' with a specific verb and resource. It also distinguishes from siblings like compare_rates by targeting date flexibility, and the context of searching for cheapest time to stay is explicit.

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

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

The description gives a clear usage scenario: 'Use this when a user has flexible dates and wants to find the cheapest time to stay.' It does not explicitly state when not to use or compare to siblings, but the context is sufficient for an agent to decide when to invoke this tool over alternatives like compare_rates.

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 destructiveHint=false. Description adds that the operation requires an API key, returns a formatted list, and notes the response will indicate how many more trips exist. No contradictions.

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?

Well-structured with a clear summary line, then details in paragraphs. Each sentence adds value; no wasted words. Could be slightly more concise but overall efficient.

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, output schema exists), the description covers purpose, auth requirement, parameter usage, and return format. Annotations cover safety. No 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 0% schema description coverage, the description fully compensates by explaining the limit parameter's default, ordering, and when to increase it. Adds semantic guidance beyond the schema's type and 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?

The description clearly states the verb 'Get' and resource 'past trips', listing specific sub-resources (hotel stays, flights). It distinguishes from sibling tools like get_upcoming_trips by focusing on past trips.

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 requirement of a Gondola account (API key). Provides guidance on when to raise the limit parameter ('only when the user wants their full history'). Lacks explicit comparison to alternatives but context from sibling names and description is sufficient.

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 destructiveHint=false. The description adds valuable context: returns card details, payment ID, and chat-booking capability. No contradictions.

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, front-loaded with purpose and prerequisite. The bullet list of return values adds clarity without redundancy. Every sentence serves a purpose.

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 parameters and a referenced output schema, the description covers prerequisite, return data details, and purpose. It is fully complete for a listing 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?

Zero parameters, schema coverage 100%. Baseline is 4. The description adds value by explaining what is returned, compensating for no parameter 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 verb 'List' and the resource 'saved payment methods for booking'. Among siblings, there are no other payment methods tools, so it is uniquely identified.

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 mentions a prerequisite ('Requires a Gondola account (API key)') and explains the returned data's relevance (payment ID needed for book_hotel tool, bookable in chat). It does not explicitly state when not to use, 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 provide readOnlyHint and destructiveHint. Description adds useful behavioral context: requires API key, returns list of active alerts with intended output structure. Does not contradict 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?

Five sentences with front-loaded main action. Each sentence adds value: purpose, elaboration, requirement, return description. Could combine first two sentences but still 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?

Given zero parameters, good annotations, and presence of an output schema, the description adequately covers purpose, return values, and prerequisite. Lacks mention of potential limitations (pagination, max alerts) but sufficient for a simple 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?

No input parameters exist (schema is empty). Description does not add unnecessary parameter info. Baseline score for 0 parameters is 4, and the description appropriately focuses on purpose and output rather than 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?

Clearly states 'Get all active rate alerts for the current user' with specific verb and resource. Distinguishes from siblings like create_rate_alert by focusing on retrieval. Elaborates on what rate alerts are (monitoring hotels for price drops).

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

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

No explicit guidance on when to use this tool versus alternatives like search_hotels or delete_rate_alert. Only mentions a prerequisite (Gondola account with API key), but no context on when it's appropriate to call this instead of other 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 already provide readOnlyHint=true and destructiveHint=false, so description doesn't need to reiterate safety. It adds value by specifying the return type (list with rates and ratings) and implying a safe query 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 concise with a clear structure: a one-line purpose, a usage note, and Args/Returns sections. Every sentence adds value without 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?

Given that an output schema exists (though not shown), the description adequately describes the return as a list of similar hotels with rates and ratings. It could mention potential limitations (e.g., number of results) but is complete for typical use.

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 0% schema description coverage, the description fully compensates by explaining each parameter: hotel_id (Vervotech property ID), checkin/checkout (YYYY-MM-DD format), and num_adults (default 2). This adds essential 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?

The description clearly states 'Find hotels similar to one the user is looking at' and provides usage examples. It distinguishes this tool from sibling tools like book_hotel or get_hotel_details by focusing on similarity and 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?

Explicitly says 'Use this when a user wants alternatives, comparisons, or asks show me hotels like this one.' While it doesn't explicitly state when not to use, the context is clear and it implies appropriate usage 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context: it uses user preferences, recent searches, popular destinations, and upcoming holidays, and returns preview hotel results. This goes beyond annotations, though it could mention if it requires user login or has latency.

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 with three sentences: a clear purpose statement, a detail sentence, and a usage guideline. The 'Returns:' line is structured well. Every sentence adds value without fluff.

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 parameters, read-only annotations, and an output schema, the description covers the tool's purpose, behavior, and usage scenario completely. It does not need to explain return values as output schema handles that.

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 schema coverage is 100% by default. The description correctly does not mention parameters, and the baseline of 4 applies for no-param tools.

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 provides personalized travel suggestions and inspiration, distinguishing it from search and booking tools. Unlike 'search_hotels' which requires explicit criteria, this tool is for exploratory use when the user has no destination in mind.

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 says 'Great for when the user doesn't know where to go,' which gives a clear usage context. While it does not list when not to use or mention alternatives directly, the context implies use cases differentiate it from sibling tools like 'search_hotels'.

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 destructiveHint=false. Description adds requirement for Gondola account (API key) and describes return format (formatted context or instructions). Provides useful behavioral context 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?

Five sentences, front-loaded purpose, no wasted words. Includes usage instruction, prerequisite, and return description. Ideal length for a simple 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 parameters, presence of output schema, and comprehensive annotations, the description covers when to call, what it returns, and prerequisites. Fully adequate for an agent to select and invoke 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?

No parameters exist (schema coverage 100%), so baseline is 4. Description correctly omits param details as they are unnecessary.

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?

Description clearly states the tool gets saved travel context for personalization, lists specific data (loyalty, home airport, preferences), and specifies it's the best source of traveler identity. Distinguishes from siblings by framing as a single call to initialize recommendations.

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 advises to call once at start of travel/planning session and weigh across recommendations. Lacks explicit when-not-to-use or alternatives, but context is clear and practical.

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 and destructiveHint. The description adds value by stating the auth requirement (Gondola account/API key) and return format (formatted list or instructions). No contradictions.

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?

Very concise: two paragraphs plus bullet points. The main purpose is front-loaded, and every sentence adds value. Well-structured with clear sections.

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 zero parameters, a read-only operation, and an existing output schema, the description covers all necessary context: what it does, how to use the output, prerequisites, and return type.

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 has 0 parameters, so baseline is 4. Description does not need to add parameter info. It correctly explains the tool's output and how to use the profile ID.

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

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

Clearly states the tool retrieves travel profiles (guest name, email, phone presets). Distinguishes from siblings like update_traveler_profile and book_hotel by specifying the output (Profile ID) and use case.

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 explains when to use the tool: to prefill guest details when booking. Provides alternative (collecting fields individually) and notes the requirement of a Gondola account/API key. No ambiguity.

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 indicate readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: it requires authentication, returns a summary with specific fields (dates, confirmation numbers, costs, etc.), and handles cases where no account is connected by providing instructions. This goes beyond annotations to inform the agent about side effects and response format.

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 concise sentences, each serving a purpose: purpose, what's returned, and prerequisites. It is front-loaded with the main action and remains free of fluff. 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?

Given no parameters, clear annotations, and an output schema (not shown but flagged as present), the description covers the essential elements: purpose, return content, and authentication. It slightly lacks edge-case details (e.g., behavior when no trips exist), but overall it is sufficiently complete for an agent to understand and invoke the tool correctly.

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

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

The tool has zero parameters and the schema coverage is 100% (trivially). The description compensates by explaining the return value content (summary with dates, confirmations, costs, etc.). No parameter details are needed, and the description adds value by clarifying what the tool outputs.

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 ('Get'), the resource ('upcoming trips'), and specifies what is included ('hotel stays, flights, and car rentals'). It distinguishes the tool from siblings like 'get_past_trips' and specific booking tools by focusing on a comprehensive summary of all upcoming reservations.

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 mentions the prerequisite of a Gondola account (API key), which provides usage context. While it doesn't explicitly list alternatives or when not to use, the tool's purpose is distinct enough from siblings like 'get_booking' (specific booking) and 'get_past_trips' to guide selection.

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 set readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds that it returns details including vendor, pickup/dropoff, etc., which is helpful but doesn't disclose additional behaviors like authentication requirements or error cases. With annotations covering the core safety, 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 description is concise with a clear main sentence followed by structured Args and Returns sections. While the labels are somewhat redundant, the content is front-loaded with the purpose and every sentence adds value.

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

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

Given the tool has only one parameter and an output schema (not provided but indicated), the description adequately covers the return categories. For a simple read operation, it is sufficiently complete, though it omits error conditions.

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

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

Schema coverage is 0%, but the description explains booking_id as 'The Gondola booking ID (confirmation number)', adding meaningful context beyond the schema's 'Booking Id'. This clarifies the parameter's purpose and format, fully compensating for the schema 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?

The description clearly states 'Get details for a specific vehicle booking', identifying the verb 'get' and resource 'vehicle booking'. The annotation title 'Get a rental car booking' reinforces this. It distinguishes from sibling tools like get_vehicle_booking_coverage by focusing on details of a specific booking by ID, though it doesn't explicitly differentiate.

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 lacks explicit guidance on when to use this tool versus alternatives such as get_vehicle_booking_coverage or get_vehicle_booking_link. It only implies usage when having a booking ID, but provides no when-not-to-use or context for choosing among 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=true and destructiveHint=false, signaling a safe read operation. The description adds that it returns 'coverage details or an error message', which is consistent but doesn't provide additional behavioral context like data freshness or required permissions.

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

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

The description is extremely concise: one sentence for purpose, then args/returns. It is front-loaded and contains no fluff.

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 low complexity (1 param, no nested objects, annotations cover behavior), the description fully covers purpose, input, and output. An output schema exists, and the description mentions return values.

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 explains 'booking_id: The Gondola booking ID of the vehicle booking', which adds meaning beyond the schema's type and name. This is sufficient for a single parameter.

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

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

The description clearly states the tool retrieves 'rental car CDW/LDW coverage stored at booking time for a vehicle booking', using a specific verb ('get') and resource. This distinguishes it from sibling tools like 'get_vehicle_booking' (which likely gets the booking itself) and 'credit_card_coverage'.

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 on when to use this tool versus alternatives (e.g., 'get_vehicle_booking' or 'credit_card_coverage'). The description does not specify prerequisites, limitations, or when not to use it.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, and the description adds behavioral details: it returns a deep link, and the response differs by auth status. 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?

The description is relatively concise at 6-7 lines, with clear Args and Returns sections. Information is front-loaded with the purpose. Minor redundancy could be trimmed, but overall well-structured.

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

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

The description covers the auth-context, source of each parameter, and the return format (booking instructions tailored to auth status). With an output schema likely present, the description provides sufficient context 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?

The input schema has 0% description coverage, but the tool description includes an Args section explaining each parameter's origin (e.g., search_id from search_vehicles, vendor_code from search results) and format (e.g., ISO datetime). This adds significant 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?

The description clearly states the tool gets a Gondola.ai deep link for a specific vehicle from search results. It uses the verb 'get' and specifies the resource 'vehicle booking link', distinguishing it from siblings like book_vehicle (for booking) and get_booking_link (generic).

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 behavior for authenticated vs anonymous users and mentions book_vehicle as an alternative for authenticated users. However, it does not explicitly state when to use this tool over other link-related siblings like get_booking_link.

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 destructiveHint=false, so the safety profile is clear. The description adds that it returns details like extras and policies, but does not reveal other behaviors like authentication requirements or rate limits. With annotations covering the key traits, a score of 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 description is extremely concise: a one-line purpose, a one-line usage note, then parameter list and return summary. No wasted words; front-loaded with key 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 explains the tool's place in the workflow (after search_vehicles), lists all parameters, and indicates return content (extras, charges, policies). Given the output schema exists, the description sufficiently covers what an agent needs to know.

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% (no descriptions in schema). The description compensates by explaining each parameter: vendor_code (with examples like 'ZE' for Hertz), rate_code, and search_id. This adds meaningful context that the schema alone does not provide.

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 'Get detailed information about a specific rental vehicle option' and enumerates specific content: 'extras, insurance options, charges, and cancellation policy'. This clearly distinguishes from sibling tools like search_vehicles and get_vehicle_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 says 'Use this after search_vehicles', providing clear sequential context. Does not mention when not to use or alternative tools, but the context is sufficient for typical usage.

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 indicate readOnlyHint=true and destructiveHint=false, so safety is clear. The description adds that it takes no arguments, returns a Markdown summary or instructions to connect accounts, and tailors results when travel profile is available. This adds useful behavioral context 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?

The description is well-structured: it starts with the core purpose, then provides details, usage guidelines, and return format. Every sentence adds value, and there is no 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?

Given the tool's complexity (portfolio analysis) and that there are no parameters, the description thoroughly explains what it does, when to use it, and what it returns. It covers all necessary aspects including tailoring to travel profile and the case when no accounts are linked.

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 no parameters and schema coverage is 100%. With 0 parameters, the baseline is 4. The description does not need to add parameter semantics; it correctly states 'Takes no arguments.'

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

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

The description clearly states the tool analyzes the user's loyalty portfolio and surfaces high-value actions, specifying it is trip-independent and covers all programs and transferable currencies. It distinctly differentiates from sibling tools like search_hotels and compare_rates.

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 says when to use: when the user asks how to make the most of points, what's expiring, or where to transfer. It provides an alternative for booking specific trips, directing to search_hotels/compare_rates, offering clear usage boundaries.

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, destructiveHint=false. The description adds value by stating it uses historical price data, returns recommendation with confidence and signals, and is non-destructive.

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?

Description is clear and organized with purpose, usage, and args list. However, the args list largely repeats schema information, which could be more 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?

Given 6 params (5 required), output schema exists, and annotations cover safety, the description is fairly complete. It covers purpose, usage, and parameter semantics, though lacks limitations like data availability.

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 description must compensate. It explains hotel_id as 'Vervotech property ID', date format, cost and currency meaning, and optional points cost, adding meaning beyond the schema types.

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 'Predict whether now is a good time to book a hotel' with a specific verb and resource. It distinguishes from sibling tools like compare_rates or diagnose_rates by focusing on timing advice using historical price data.

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 'Call this when a user asks "Should I book now or wait?"' and lists required inputs. Lacks explicit when-not-to-use or alternatives, but 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 readOnlyHint=true and destructiveHint=false, but the description adds significant context: ranking by loyalty/status, cash-priced nature, use of Google Flights API, and mode restrictions. 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?

The description is moderately long but well-structured with sections for overview, ranking, and detailed parameter descriptions. Each sentence adds value, though some redundancy exists (e.g., repeating cash-priced).

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 10 parameters and an output schema (mentioned but not shown), the description covers inputs thoroughly and briefly describes the output structure. It provides enough context for an agent to understand and invoke the tool correctly, though more detail on output fields could be added.

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?

All 10 parameters are thoroughly explained with examples, formats, and constraints. The description compensates for the 0% schema coverage by detailing origins, destinations, date format, cabin_class enum, pagination, and optional filters like airlines and max_stops.

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 starts with 'Search for flights by route and date and return cash-priced options,' which clearly states the verb ('search'), resource ('flights'), and key specifics (route, date, cash-priced). This distinctly separates it from sibling tools like search_hotels or search_vehicles.

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 explains pagination ('call again with page=2...') and mode usage ('book' only if user explicitly asks to book). It gives clear context on when to use each mode and how to get more results, though it does not explicitly list alternatives for when not to use this tool.

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 indicate readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds detailed behavioral traits: returns side-by-side rates with CPP valuation, chain_name's fallback behavior (returns unfiltered results with a note if no match), loyalty_programs for personalization, and limit indicating how many more results exist. This significantly enhances transparency 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?

The description is well-structured with a clear front-loaded purpose and organized parameter list. Every sentence adds value, and the length is appropriate for the tool's complexity (8 parameters). No wasted words.

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

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

Given the tool has 8 parameters, 0% schema coverage, and an output schema exists, the description is complete. It covers all parameters, return values (formatted list with CPP and deal recommendations), and special behaviors (chain_name fallback, personalization). No gaps remain.

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%, but the description provides comprehensive semantics for all 8 parameters: location examples, date formats, num_adults default, chain_name case-insensitive matching and fallback, loyalty_programs and loyalty_points for personalization and affordability, and limit with usage guidance. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Search for hotels by location and dates with cash AND points pricing.' It highlights the unique advantage of side-by-side rates, CPP valuation, and deal scores, effectively distinguishing it from siblings like compare_rates and get_hotel_details.

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 context on when to use the tool (searching hotels with both cash and points pricing) and offers guidance for parameters like limit ('raise this only when the user explicitly wants a longer list'). However, it lacks explicit when-not-to-use instructions or direct comparisons to sibling tools, missing some exclusion 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 indicate readOnlyHint=true and destructiveHint=false, so the description adds limited behavioral insight. It mentions returning a list of available vehicles with rates, but does not disclose additional traits like data freshness or pagination.

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 well-structured with bullet-pointed arguments and a clear opening sentence. It is efficient but not overly concise; the param list takes space but 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?

Given an output schema exists, the description adequately covers parameters and mentions return type. It is complete for a search tool, though it could note optionality of vehicle_class more explicitly.

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 description coverage at 0%, the description fully compensates by detailing each parameter: IATA code for pickup_location, ISO format for datetimes, and enum values for vehicle_class. This adds critical meaning beyond the bare schema.

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

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

The description clearly states the tool searches for rental vehicles at an airport or city, with specific verb 'Search' and resource 'rental vehicles'. It distinguishes from siblings like 'book_vehicle' and 'get_vehicle_details'.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives (e.g., 'get_vehicle_booking' or 'book_vehicle'). It implies usage before booking but lacks when-not 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?

Adds context beyond annotations: explains that saved entries persist across sessions via get_traveler_context, mentions API key requirement, and describes return behavior (confirmation or error). No contradictions with annotations (readOnlyHint=false, destructiveHint=false). Could further specify rate limits or idempotency, but sufficient for a write tool.

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

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

Well-structured with purpose first, then usage guidelines, persistence note, requirement, and parameter description. Each sentence adds value; no waste. Appropriate length for a simple write 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?

Covers all necessary aspects: purpose, when to use, what to save, prerequisites, return behavior. No gaps given the tool's simplicity and the presence of annotations and 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 0% but description provides detailed guidance on the single parameter: examples of good vs bad entries, encouragement to be specific and actionable. Adds meaningful usage advice beyond schema type definition.

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

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

Description explicitly states it saves a learned travel preference or experience to the user's traveler profile, with specific examples of durable preferences vs temporary logistics. Clearly distinguishes the action and resource.

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 explicit when-to-use (durable preferences, likes, dislikes, trip experiences) and when-not-to-use (temporary logistics like flight landing time). Also mentions prerequisite (Gondola account) and references sibling tool get_traveler_context for retrieving saved entries.

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