MolTravel

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

With no annotations, the description bears full responsibility for behavioral disclosure. It states the lookup action (implying read-only) and code formats, but does not mention edge cases, return behavior, or any other operational details. It is not misleading, but minimal.

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

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

A single, clear sentence that front-loads the purpose and directly specifies the accepted inputs. Every word contributes to the meaning, and there is no redundant 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?

For a simple lookup tool with a single parameter, the description is sufficient. The purpose and input format are fully stated, and an output schema exists to cover return values. No additional context is necessary for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by defining 'code' as an IATA (2-char) or ICAO (3-char) airline code, which is essential for correct parameter usage. This goes beyond the bare schema and gives the agent actionable format constraints.

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

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

The description clearly states the action ('Look up an airline') and the specific resource, with precise input formats (IATA 2-char or ICAO 3-char). This differentiates it from airlines_search (which likely searches by name) and airports_lookup (which handles airports), making the purpose unambiguous.

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

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

There is no explicit guidance on when to use this tool versus airlines_search or other alternatives. The phrase 'by IATA or ICAO code' implies usage when a code is available, but no exclusions or alternative tools are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds a concrete behavioral limit ('Returns up to 20 results'), which is useful, but it does not disclose behavior like whether the 'active_only' filter is applied by default, sorting, 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 very concise and front-loaded, using a single sentence with no filler. It is appropriately sized for a simple search tool, though it could have included a bit more parameter context without becoming verbose.

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 params, 1 required) and the presence of an output schema, the description covers the core search purpose and result limit. However, it omits the optional filtering parameters' behavior and offers no sibling differentiation, leaving some gaps for an agent deciding among similar tools.

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 for explaining parameters. It only adds meaning to the 'query' parameter ('by name'), while the 'country' and 'active_only' parameters remain unexplained, leaving a significant semantic 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 the action ('Search') and the resource ('airlines'), with a specific filter ('by name'). It is precise but does not explicitly distinguish this tool from the sibling 'airlines_lookup', so it falls short of a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'airlines_lookup' or when to prefer other search tools. There is no mention of suitable contexts, prerequisites, or exclusions.

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

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

With no annotations, the description carries the transparency burden. It discloses output behavior ('Returns full details including runways') and the required input format. The verb 'look up' implies a read-only operation, which is sufficient for a lookup tool. It does not mention error cases or permissions, but for a simple read operation this is acceptable.

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

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

The description is two short sentences, front-loaded with the core purpose. Every word adds value: the code formats, the return details, and the runway mention. No filler or redundancy.

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

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

For a simple single-parameter lookup tool with an output schema, the description covers purpose, parameter format, and return characteristics. Sibling tool differentiation is inferable from the description, and no additional context is needed. It is complete for the tool's 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?

Schema description coverage is 0%, so the description fully compensates by explaining the 'code' parameter: it accepts IATA (3-char) or ICAO (4-char) codes. This adds critical meaning beyond the schema's bare 'string' type, making the parameter self-explanatory.

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 'Look up an airport by IATA (3-char) or ICAO (4-char) code', specifying the verb (look up), resource (airport), and exact input type. It distinguishes from sibling tools like airports_search and airports_near, which handle name-based or location-based lookups.

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

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

The description implies the use case: when you have an IATA or ICAO code, use this tool. It doesn't explicitly mention alternatives or exclusions, but the code-based scope gives clear context, and the sibling tool names (e.g., airports_search, airports_near) provide additional differentiation in context.

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

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

With no annotations, the description carries the full burden. It adds 'Returns results sorted by distance,' which is a useful behavioral trait. However, it does not disclose default radius, limit handling, or the meaning of include_small, which could be relevant for agent decision-making.

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 one sentence of 13 words, front-loading the purpose with no redundancy. Every word earns its place, making it highly concise and well-structured.

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

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

For a tool with 5 parameters, no annotations, and no schema descriptions, the description is minimal. It covers the core function and sort order, but lacks explanations of the optional parameters (limit, radius_km, include_small) that could affect the output. An agent might struggle to correctly set include_small or understand the default radius. The presence of an output schema mitigates the need to describe return values, but the description remains incomplete.

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%, and the description mentions no parameters by name. It only vaguely references 'geographic point,' which maps to latitude/longitude but does not explain limit, radius_km, or include_small. The description adds no meaningful parameter information beyond what the schema already 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 uses a specific verb ('Find') and resource ('airports') with a clear scope ('near a geographic point'), which distinguishes it from sibling tools like airports_lookup and airports_search. It also notes the sort order, making its function unmistakable.

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

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

The description implies a use case (finding airports near coordinates) but does not explicitly mention when to choose this tool over alternatives or any exclusions. The context is clear, but guidance on tool selection is only implied, not stated.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals a 20-result cap and sorting by size, which is useful. But it does not clarify query matching behavior (exact vs. partial), case sensitivity, or possible error conditions. No contradiction with annotations exists since none are present.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently covers the core purpose and a key behavioral detail, making every word earn its place.

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

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

For a simple search tool with three parameters and an output schema, the description provides a baseline of completeness: it clarifies search scope, result limit, and ordering. However, it omits semantics for optional filters and offers no comparative context with sibling tools. The output schema mitigates the need to describe 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 for all parameters. It only explains the 'query' parameter as searching by name or city. The optional 'country' and 'type_filter' parameters are completely unexplained, leaving their accepted values and purpose ambiguous.

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 'Search airports by name or city,' specifying a concrete verb and resource. It also adds scope details (returns up to 20 results sorted by size) that distinguish it from sibling tools like airports_lookup (likely exact code lookup) and airports_near (geographic search).

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 intended use is implied: use this when you need to find airports by name or city. However, there is no explicit guidance on when NOT to use it, alternatives such as airports_lookup or airports_near are not mentioned, and no prerequisites or exclusions are stated.

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

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

No annotations are provided, so the description carries the burden. 'Check' implies a read-only operation, but the description does not disclose potential caveats such as what happens if datasets are not loaded or whether there are any side effects. It is adequate but minimal.

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

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

The description is one concise sentence, front-loaded with the verb, with no wasted words. It efficiently communicates the tool's 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 tool's simplicity (no parameters, output schema exists), the description is sufficiently complete. It lists the relevant datasets and what to expect (row counts), though it could optionally mention the meaning of 'loaded'.

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

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

The tool takes no parameters (schema coverage 100% with empty properties), so there is nothing to explain. Per the rubric, a baseline of 4 is appropriate when there are zero parameters.

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

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

The description clearly states the tool's function: checking which static datasets (airports, airlines, visas) are loaded and their row counts. The verb 'Check' is specific, and the resource is well-defined, distinguishing it from sibling lookup/search 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?

The description implies usage context (checking data availability) but does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. For a simple status check, the guidance is sufficient but not explicit.

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

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

No annotations are provided, so the description carries the full burden. It accurately indicates a read-only list operation with no side effects, but adds no further behavioral context such as data completeness, ordering, or response details. This is adequate for a zero-parameter list tool but not comprehensive.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently communicates the tool's scope and action without any filler, earning a top score for conciseness.

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

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

For a simple list tool with no parameters and an output schema present, the description sufficiently defines the tool's scope ('all countries with UK FCDO travel advice'). It provides the necessary context for an agent to decide when to invoke this tool and what to expect.

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

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

The input schema has zero parameters, so there are no parameter meanings to clarify. Baseline of 4 applies for zero-parameter tools, and the description adds no irrelevant parameter information.

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 uses a specific verb ('List') and resource ('all countries with UK FCDO travel advice'), clearly distinguishing it from sibling fcdo_travel_advice which likely provides per-country details. The purpose is immediately obvious and actionable.

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 use when a list of all FCDO-covered countries is needed, but does not explicitly state when to use it versus alternatives like fcdo_travel_advice. No exclusions or alternative mentions are provided, leaving usage to inference.

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

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

No annotations are provided, so the description must carry the transparency burden. It adds useful context by listing what the advice includes (safety, entry requirements, health, warnings), but does not disclose whether authentication is needed, data freshness, or any potential side effects. The tool appears read-only, but this is not explicitly stated.

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

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

The description is a single, efficient sentence that front-loads the tool's identity and lists key contents without redundancy. The '[fcdo]' prefix adds context without wasting space.

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

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

The tool is simple (one parameter, output schema exists), but the description does not explain how to obtain a valid country name (e.g., via 'fcdo_list_countries') or how it relates to overlapping tools like 'visa_check'. While the content list helps, this leaves some gaps in the broader context.

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 no description for the 'country' parameter (0% coverage), and the tool description only repeats 'specific country' without specifying the expected format (e.g., name vs ISO code) or giving an example. This leaves the agent guessing about how to supply valid input.

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

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

The description clearly states a specific verb ('Get') and resource ('UK FCDO travel advice') with scope ('for a specific country') and lists key content areas (safety, entry requirements, health, warnings). It naturally distinguishes from the sibling tool 'fcdo_list_countries' by focusing on a single country rather than listing all.

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 phrase 'for a specific country' implies when to use, but there is no explicit comparison to alternatives such as 'visa_check' or 'restcountries_country_info', nor any guidance on when not to use. Usage context is implicit, not differentiated.

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

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

No annotations were provided, so the description carries the transparency burden. It discloses the key behavior (direct routes, no transfers, destination ports), but it does not state whether the op is read-only, what happens for no-match inputs, rate limits, or any errors. The 'get' name implies read behavior, but the description does not confirm it.

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

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

One sentence front-loaded with the main purpose and zero filler. The key qualifier 'without transfers' appears at the end and adds precision without bloat.

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 single-param tool with no output schema and no annotations, the description is mostly complete: it tells the agent what to provide (origin) and what to expect (routes and destination ports). Missing explicit detail about response format or whether schedule/price information is included, but for a simple 'find direct connection' tool that gap is minor.

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 already fully describes portLocation as a location name/search term not limited to exact port codes. The description adds a useful semantic detail: this parameter is the origin port. That connection between the description and the param is valuable enough to exceed the baseline.

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

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

The description uses a clear, specific verb ('Find') and names the exact resource: all direct ferry routes and reachable destination ports from an origin port. It also distinguishes itself from trip-search and port-lookup siblings by explicitly stating 'without layovers or transfers'.

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 intended use case is implied: use this when you need direct ferry connections or reachable ports from an origin port. However, there is no explicit guidance on when not to use it or when to prefer alternatives like ferryhopper_search_trips, ferryhopper_get_ports, or ferryhopper_get_disruptions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only restates the tool's purpose and does not mention return format, pagination, staleness of data, scope limitations, or any unexpected behavior. As a result, the agent learns that the tool exists but not much more than the schema already implies.

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

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

The description is a single, well-structured sentence that leadss with the action, then the subject of the tool, then the disruption types, then the filters. Vestigial prefixes like '[ferryhopper]' are minor and not harmful.

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 and schema together provide enough information to invoke the tool: what it returns in general terms, the required parameters, and their formats. However, there is no guidance on usage conditions, return structure, or how to handle empty/unavailable disruption data, which leaves some gap for a no-annotation tool.

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

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

The input schema provides full descriptions for both parameters, including examples for country and tripDate. The description adds little beyond those schemas, but since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Find') and resource ('all ferry travel disruptions'), and it enumerates the disruption types (delays, weather alerts, strikes) and filters (date and country). It does not explicitly differentiate from sibling ferry tools like trip/search tools, but its meaning is unambiguous on its own.

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

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

The description implies when the tool should be used: when a user asks about ferry delays, weather alerts, or strikes for a specific date and country. However, it gives no explicit guidance about when to prefer this over sibling tools such as search/trip/trip-details tools, nor does it mention exclusions or alternative conditions.

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

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

With no annotations and no parameters, the description provides a modest explanation: 'Find ferry ports' indicates a read-only retrieval, and the content categories (ports, IDs, codes, locations) hint at the return data. It doesn't mention scale, formatting, or limitations, but for a simple 0-parameter list tool the disclosure is acceptable.

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 one concise sentence that starts with the primary action, 'Find ferry ports'. It avoids fluff. The long list of data types is slightly dense, but every item contributes to clarifying the tool's 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?

For a no-parameter tool with no output schema, this description is fairly complete: it tells the agent what kind of data will be returned. It could mention that this is a full list, but given zero parameters, the scope is reasonably predictable.

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

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

The input schema has zero properties, so there are no parameters to document. The description still neither ensures but there is no conflict. The 0-parameter baseline of 4 applies because no paraminfo is needed.

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

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

The description opens with the actionable verb 'Find' and identifies the resource as 'ferry ports, harbors, maritime terminals, port IDs, codes, and geographic locations.' This is specific enough to distinguish it from sibling ferryhopper tools that relate to trips, disruptions, or direct connections, though it doesn't explicitly contrast with those siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives such as airplane... Sorry, there is no mention of how this relates to ferryhopper_get_direct_connections_for_ports or search_trips. It does not mention when the tool should be called first or what workflow it supports, so an agent is left to infer from the name.

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

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

No annotations are present, so the description carries the full behavioral burden. It discloses that the tool is deprecated and is one-way only, which is meaningful behavioral context. However, it does not mention what the actual response body returns, output limits, error conditions, or whether it retrieves real-time data, which would help an agent understand the behavior of a read-only search API.

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

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

The description is two sentences long, with the deprecated warning and canonical replacement front-loaded to prevent a mistake. The one-sentence functional description that follows is efficient and contains no 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?

The tool has only 3 input parameters, all are required, all are fully described in the schema, and the description clarifies the tool's scope and deprecation status. There is no output schema, but the description is sufficient for the agent to know what kind of list it will get. It could stir in more detail about the return structure, but for a deprecated tool that is simply sent to v2, the key selection information is already present.

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 three parameters are already explained in the schema with human-readable examples (e.g., 'date' described with YYYY-MM-DD and example). The description adds no additional parameter-level semantics beyond telling the agent that it searches from one port to another on a specific date. Since schema coverage is 100%, this is the appropriate baseline.

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

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

The description opens with a clear violation: 'Get a list of available one-way ferry trips between two ports on a specific date.' It names the exact resource (ferry trips), the action (search/list), and the scope (one-way, two ports, date), which distinguishes it from other ferryhopper tools. The deprecation line further identifies the successor by name, so there is no ambiguity.

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 'Deprecated: prefer search_trips_v2' and explains what the new tool covers that the current tool does not (round-trip search and per-segment availability flags). This is a clear, direct when-to-use alternative for agents, and the advantage is more evidence about the new tool, so the agent can decide which to call.

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

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

With no annotations at all, the description has the full burden of behavioral disclosure. It goes beyond a pure label by disclosing round-trip behavior and the fact that per-segment availability flags for cabin, vehicles, pets, and e-ticket are returned. It is not exhaustive about pagination, errors, or read-only behavior, but it provides meaningful behavioral 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?

Two concise sentences with no filler. The core purpose is front-loaded and each sentence contributes additional relevant detail: one-way availability, round-trip support, and segment-level flags.

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?

It is complete enough to make a basic call using the required parameters, and the schema fills in param details. However, there is no output schema and no annotation, and the description does not say what happens with ambiguous location names, how the trip list is scoped, or how this differs from `ferryhopper_search_trips`. Given the number of sibling ferry tools, a little more context could be expected.

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

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

Schema description coverage is 100%, so every parameter already has a clear meaning. The description adds round-trip behavior, but that is largely redundant with the `returnDate` parameter description. There is no extra parameter-level insight beyond the schema.

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

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

States a clear verb and object: get a list of ferry trips between two ports for a date, and mentions optional round-trip support. It is clear enough to select from most unrelated siblings, but it does not distinguish itself from the nearly identical sibling `ferryhopper_search_trips`, so it cannot receive a 5.

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

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

The description implies when to use it: for available trips between two ports on a date and for round-trip searches when a return date is given. It does not explicitly say when not to use it or name alternatives like `ferryhopper_trip_details` or `ferryhopper_get_direct_connections_for_ports`.

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

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

With no annotations, the description must carry the full behavioral burden. It does so exceptionally: it discloses the null semantics ('data is unavailable, not that the vessel lacks that amenity'), the exact throwing conditions (malformed tripId, trip already departed/cancelled/sold out), and the fallback action. It also mentions when hasDetails is false.

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?

This is a long description, but every sentence earns its place: purpose, primary output, example user questions, null safety semantics, error handling, and data provenance. It is front-loaded with the key lookup relationship and the fallback advice is placed exactly where the failure mode is discussed.

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?

Since there is no output schema, the description is comprehensive enough for a single-trip details endpoint: it covers what is returned, the null/unavailability construct, error behavior, and re-query strategy. The agent can select and invoke it without requiring another schema.

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

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

The schema already covers tripId well with 100% coverage, including 'Do not fabricate this value.' The description adds slight value by emphasizing the tripId originates from search_trips_v2 and by tying invalid IDs to error behavior, but does not need to carry much weight here due to the excellent 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 leads with a strong verb+resource framing: 'Get full details for a single sailing leg, looked up by the tripId returned by search_trips_v2.' It clearly differentiates itself from sibling tools by naming the exact source of lookup and the kind of data returned (vessel details, amenities, photos).

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 where to obtain the tripId from (search_trips_v2), what user questions it answers (wifi, access, capacity, etc.), and how to handle stale/homomorphic IDs by re-running search_trips_v2. This gives clear and actionable when-to-use guidance.

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

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

With no annotations, the description carries the behavioral burden. It clearly implies a read-only lookup via 'peek' and 'Get', but it does not explicitly state that nothing is modified, nor does it mention auth, rate limits, or output edge cases. This is acceptable for a simple lookup but not fully transparent.

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

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

The description is a single front-loaded sentence that names the action, resource, and key return details without filler. The '[peek]' prefix is minor but harmless, and every part of the sentence contributes useful context.

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

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

For a straightforward read-only availability lookup with fully documented parameters, the description captures the essential context and return content. There is no output schema, but the description's mention of dates, times, and pricing gives enough of a picture for tool selection and 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 already documents all four parameters with full coverage, including inclusive-date semantics and quantity. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Get'), the resource ('availability information for a specific experience'), and the content included ('dates, times, and pricing'). This distinguishes it from siblings like peek_experience_details and peek_search_experiences.

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 a clear use case: you need availability for a specific experience, so you must already have an ID and date range. It does not explicitly compare against peek_experience_details or other alternatives, so it stops short of full guidance.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does not state whether the operation is read-only (though 'peek' hints at it), what happens if the ID is not found, whether authentication is required, or any error behavior. The description is purely functional and lacks these contextual details.

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

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

The description is a single, well-structured sentence that immediately states the action and target. It is front-loaded with the tool category marker '[peek]' and avoids any redundant wording. Every element earns its place, and there is no filler.

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

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

For a simple get-by-ID tool with one parameter and no output schema, the description is mostly adequate but leaves some gaps. It does not describe the returned data structure or handle cases like invalid/missing IDs. Given the simplicity and strong schema coverage, it is minimally viable but could mention expected output or error behavior to be more self-contained.

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 provides 100% coverage: the only parameter ('id') has a clear description ('The ID of the experience to retrieve'). The description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate. No extra syntax or formatting is needed for a single string 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?

The description uses a specific verb ('Get') and clearly identifies the resource ('detailed information about a specific experience') and the selection criterion ('by ID'). It naturally distinguishes itself from sibling tools like peek_search_experiences, which are for broader searches, making it immediately clear this is a singular retrieval operation.

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 clearly implies the use case: when you have a specific experience ID and need detailed information. It does not explicitly mention alternative tools or exclusions, but the context (search returns lists, this returns one item) is strong enough for an agent to infer appropriate usage. A minor gap is the lack of an explicit 'use this when you have an ID' statement.

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

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

With no annotations, the description must carry the transparency burden. It clearly implies a read-only, side-effect-free behavior through the word 'list', but it does not disclose output format, ordering, or any limits. For a zero-parameter tool this is minimally adequate but not rich.

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 one short sentence, front-loaded with the action and resource, and contains no filler or redundant 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 tool is extremely simple: no parameters, no annotations, and no output schema. The description conveys the essential behavior and is probably sufficient for a list-all operation, but it could clarify the exact shape or naming of the returned category tags, leaving a small gap.

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

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

The input schema has zero properties, so the baseline is 4. There are no parameter semantics to explain, and the description does not need to add input-related meaning beyond what the empty schema already shows.

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

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

The description uses the specific verb 'list' and identifies a clear resource: 'all category tags'. The '[peek]' prefix situates it within the Peek tool family, and it is distinct from sibling tools like peek_search_experiences because it enumerates a fixed taxonomy instead of searching.

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 is provided about when to use this tool versus alternatives. The description only states the action and does not mention a context, prerequisite, or the typical workflow (e.g., using tags to filter experience searches), nor does it name any alternative 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?

Since no annotations are provided, the description carries the full burden. It conveys the core operation (rendering) and output type (widget URI), implying a read-only, non-destructive action. However, it does not explicitly state whether modifications occur, error handling, or any side effects, so transparency is adequate but not rich.

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

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

The description is a single, well-structured sentence that front-loads the [peek] tag, states the action, and specifies the return value. There is no redundant 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 the tool's simplicity (one parameter, no output schema, no annotations), the description covers the essential purpose and output. It could explicitly mention that this is a read-only rendering action or add a note about valid ID requirements, but the core functionality is sufficiently described.

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 fully documents the only parameter 'id' with a description. The tool description adds no additional semantic value beyond repeating 'list of activity IDs', which matches the schema. Per the baseline rule, a score of 3 is appropriate.

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

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

The description clearly states the tool renders activity tiles for a list of activity IDs and returns an embeddable widget URI. It uses a specific verb and resource, distinguishing it from sibling tools like peek_experience_details or peek_search_experiences.

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 activity IDs and need a widget URI, but it does not explicitly state when to use this tool versus alternatives or provide exclusions. No alternative tools are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns categories, tags, and regions with IDs, which adds context about the output shape. However, it doesn't mention whether it's read-only, pagination behavior, or other side effects beyond 'search', which is generally safe but not explicitly stated.

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

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

The description is two concise sentences, front-loaded with the core action. The second sentence adds valuable detail about the return value without redundancy or 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 the rich parameter descriptions and the absence of an output schema, the description sufficiently outlines purpose and output highlights. It could mention the actual list of experiences returned and any result format details, but the 'returns categories, tags, and regions' hint provides useful context for a search tool. This is a minor gap for a 7-parameter tool with no output schema.

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

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

Schema description coverage is 100% and each of the 7 parameters has a detailed explanation with usage examples. The tool description itself adds no parameter-specific meaning, but since the schema is thorough, the baseline of 3 is appropriate.

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

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

The description clearly states it 'Search[es] for travel experiences' and specifically notes it returns categories, tags, and regions with IDs for further filtering. This distinguishes it from sibling tools like peek_experience_availability and peek_search_regions by naming the main search functionality and its filtering-oriented metadata output.

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 it is the main search tool with 'comprehensive filtering options' but does not explicitly name alternatives or state when-not-to-use. However, parameter descriptions within the schema (e.g., latLng's 'Don't use this for regions, instead use the search_regions') provide some guidance, though that is not part of the description itself.

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

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

No annotations are provided, and the description gives only the basic search behavior. It does not disclose pagination (though schema has limit), result structure, sorting, or any side effects. This is insufficient for a tool with no safety 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 a single sentence that is front-loaded and free of filler. Every word contributes to 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 simple schema and no output schema, the description is minimally acceptable but lacks usage context or return-value expectations. An agent could use it, but might not know what regions are relevant or how results are returned.

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

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

The input schema already fully describes both parameters (query and limit) with 100% coverage. The description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description 'Search for regions by name' clearly identifies the action (search) and resource (regions) with a name-based filter. It is distinct from sibling tools like peek_search_experiences, but it does not explicitly state that distinction.

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

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

There is no mention of when to use this tool versus alternatives such as peek_search_experiences or other search tools. The description provides no context for selection, leaving the agent to infer from the name alone.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as whether it is read-only, any limitations, or output specifics. The word 'look up' implies a safe read operation, but this is not explicit.

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

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

The description is a single sentence with no filler words, front-loading the core purpose. It is as concise as possible, though this brevity comes at the cost of missing context.

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

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

With three parameters, no annotations, and no schema descriptions, the description is insufficient for an agent to construct a valid query. The existence of an output schema does not address input ambiguity.

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

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

The schema has 0% description coverage, leaving query, fields, and search_by without explanations. The tool description does not compensate, offering no details on parameter formats, allowed values, or relationships.

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 ('Look up') and resource ('country information'), and names the data source 'REST Countries', which gives it a specific meaning. However, it does not explicitly differentiate it from sibling tools like fcdo_list_countries, though the API reference helps.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description is purely declarative and does not address usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a read-only search operation and states what it returns (prices, companies, car details), but does not mention pagination behavior, date/time handling defaults, error cases, or any other side effects. This is adequate for a simple search tool but not comprehensive.

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

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

The description is a single, front-loaded sentence that conveys the purpose without any filler. Every word contributes to understanding the tool's function, making it exceptionally concise and well-structured.

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

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

The description provides a clear overview of the search operation, and the rich schema covers parameter details. However, with no output schema, the description only vaguely mentions the return format ('prices, companies, and car details'). For a search tool with 8 parameters, this is sufficient for basic selection and invocation, but additional behavioral context (e.g., pagination, defaults) could 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 coverage is 100%, so the input schema already documents all 8 parameters with descriptions. The description adds minimal new meaning beyond the schema—it highlights the core parameters (pickup/dropoff locations/dates) but does not elaborate on their formats or constraints, which are already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Search Skiplagged for rental cars between pickup and dropoff locations/dates, returning prices, companies, and car details.' It specifies the verb (search), resource (rental cars), key parameters (pickup/dropoff locations/dates), and output (prices, companies, car details), which distinguishes it from sibling flight and hotel search 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?

The description implies usage for car rental searches but does not explicitly state when to use this tool versus alternatives or when not to use it. Sibling tool names (e.g., skiplagged_sk_flights_search) provide contextual differentiation, but the description lacks explicit usage guidelines such as prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the burden. It indicates a read-only search (finding destinations) and implies a list of options, but does not detail return format, potential limitations, or whether any side effects occur. This is acceptable for a search tool but lacks explicit behavioral detail.

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

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

The description is a single, concise sentence without redundancy. It efficiently conveys the purpose and usage condition, earning a perfect score for conciseness.

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

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

Given the tool is a search function with no output schema, the description provides sufficient context: it returns lower-priced destinations. It does not specify the output format (e.g., list of destinations with prices), but this is implied by the nature of the tool and consistent with sibling search tools. Completeness is high but not exhaustive.

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 parameters in the schema have descriptive properties (e.g., from: 'Departure IATA code or city name', depart: 'Departure date in YYYY-MM-DD format'). The schema coverage is 100%, so the baseline is met. The description does not add extra parameter context, but it is not necessary given the schema's clarity.

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 function: finding lower-priced destinations from a given departure city when the user is flexible about the destination. It uses a specific verb ('Find') and resource ('destinations'), distinguishing it from flight-specific or calendar 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?

The description explicitly specifies the condition for use ('when the user is flexible about where to go'), providing clear guidance. It does not explicitly mention alternatives, but the sibling tool names imply differentiation (e.g., flex calendars, flights search), so the usage context is adequately conveyed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'search support articles', which implies a read operation, but does not disclose any further traits such as return format, pagination, rate limits, or whether results are article snippets or full text. This absence of behavioral context is a significant gap.

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

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

The description is a single, well-structured sentence that front-loads the domain tag and directly states the tool's purpose. Every word earns its place, with no unnecessary filler.

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

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

For a relatively simple tool with two documented parameters and no output schema, the description gives the minimum viable context. However, it lacks detail on what results look like and does not guide query formulation beyond what the schema already says. This leaves some ambiguity for an agent unfamiliar with the tool.

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

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

The input schema covers both parameters with descriptions: `query` for the FAQ question and `top_k` for the number of sources. With 100% schema coverage, the description adds no additional parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool searches Skiplagged support articles for answers related to services, products, and policies. This specific verb+resource combination distinguishes it from sibling tools focused on flights, hotels, or destinations.

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

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

The description provides a clear context: use this tool for FAQ-style questions about Skiplagged services, products, or policies. It implies when to use it (when user asks about support topics) but does not explicitly state when not to use it or name alternatives. This is strong contextual guidance without exclusions.

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

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

Annotations are absent, so the description carries the full burden of disclosing behavior. It does not mention any side effects, limitations (e.g., date range flexibility window, result count), authentication requirements, or error handling. It only states the output in simple terms. This is insufficient for a tool with no structured behavior 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 exceptionally concise: two sentences, with the core purpose front-loaded. Every clause adds value—the output format and the usage intent are both included without redundancy. No filler words or unnecessary details.

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 9 parameters and no output schema or annotations, the description provides only minimal context. It explains the tool's purpose and output format but omits details like the flexibility window size, whether results are limited in number, or how the 'around' date is determined. It is sufficient for a basic understanding but leaves key operational details unaddressed.

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

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

The input schema provides 100% coverage with descriptions for all 9 parameters, so the baseline is 3. The description adds a general context of 'one-way fares' and 'around a chosen departure,' but does not elaborate on any specific parameter semantics beyond what the schema already states.

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

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

The description clearly states a specific action ('Generate a flexible calendar'), the resource ('lowest one-way fares around a chosen departure'), and the output format ('date → cheapest-price entries'). It also includes a usage intent ('to help pick the best day to fly') that distinguishes it from exact itinerary searches. The phrasing 'not exact itinerary selection' differentiates it from sibling tools like flights_search.

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

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

The description provides a clear usage context—'flexible-date price discovery'—and explicitly states a limitation: 'not exact itinerary selection.' This tells the agent when to use the tool and hints at alternatives (exact search tools) without naming them. It lacks explicit 'when not to use' instructions beyond the one exclusion, so it's not quite a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses that results are nearby date pairs preserving trip length and that it is for price discovery, which is useful. However, it does not mention any limitations (e.g., number of results, date range boundaries, potential errors) or operational details like rate limits 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 two sentences, front-loaded with the main verb 'Generate', and contains no redundant phrasing. It efficiently conveys the core function, output, and intended use with zero 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 the complexity (9 params, no output schema) the description adequately covers the primary output format and purpose. It explains the returned entries and the fixed-length stay behavior, but does not mention any constraints like date ranges or result size limits. Since parameter documentation is fully handled by the schema and the tool is read-only in nature, this is reasonably complete.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds value by explaining that departureDate and returnDate define the 'chosen travel window' and that generated pairs preserve the original trip length, which clarifies how the parameters interact beyond their individual definitions.

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 generates a flexible round-trip price calendar for a fixed-length stay, and specifies the output entries (departure date, return date, lowest total price). It distinguishes itself from sibling tools like skiplagged_sk_flex_departure_calendar (which likely focuses on flexible departure) by emphasizing the fixed-length round-trip nature.

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 it is 'intended for price discovery, not exact itinerary selection', giving a clear when-not-to-use caveat. However, it does not explicitly name alternative tools (like skiplagged_sk_flights_search for exact bookings), so it lacks the 'alternatives' component for a perfect score.

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

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

With no annotations, the description carries the full burden and only says 'Search', adding little beyond the name. It fails to disclose notable behaviors such as hidden-city/virtual-interlining support, whether results include prices, how filters affect output, or that this is a read-only query. The description is too anemic for a tool with many behavioral options (e.g., includeHiddenCity, includeVirtualInterlining) that the schema implies but the description omits.

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

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

One sentence with no filler; it front-loads the vendor and purpose, then summarizes filter categories. It is concise and readable, but it sacrifices substance for brevity, so it does not quite reach a 5.

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

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

A 26-parameter tool without an output schema and with no annotations needs more guidance: return shape, how to combine filters, special Skiplagged features, or when to prefer this over the flexible-date/calendar siblings. The description does not provide enough to select and invoke confidently in complex scenarios.

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 92%, so the heavy lifting is already done by the schema. The description's summary of filters (passengers, fare class, stops, airlines, timing preferences) adds a helpful high-level overview but no specific meaning beyond the schema. Baseline of 3 is appropriate.

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

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

The description states a specific verb ('Search') and resource ('Skiplagged for flights between specific locations'), and the filter summary distinguishes it from sibling car/hotel/calendar tools. However, it does not explicitly contrast with flight-related siblings like skiplagged_sk_flex_departure_calendar or skiplagged_sk_destinations_anywhere, so it stops short of full differentiation.

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 phrase 'between specific locations' implies when to use (concrete origin/destination dates) versus open-ended 'anywhere' searches, but no alternatives are named and no exclusions are provided. Context is inferable but not explicitly guided, which is a gap given many flight-related siblings exist.

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

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

No annotations are provided, so the description carries the full burden. It adds useful behavioral context ('room-level') and lists output content (availability, pricing, amenities). However, it doesn't disclose potential side effects, rate limits, or that it's read-only, which would be expected given no safety 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 entire description is a single, front-loaded sentence that quickly conveys the tool's purpose without any fluff. It avoids unnecessary repetition and is perfectly sized for quick scanning.

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?

Even though there is no output schema, the description covers the key output categories (availability, pricing, amenities) and the input parameters are thoroughly documented. The description is sufficient for a well-understood 'details' operation, though it could have included return format nuances if needed.

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 7 parameters have rich descriptions that go beyond schema basics. For example, the 'live' parameter explains the trade-off between accuracy and speed, and 'hotelId' clarifies its source. These descriptions significantly enhance the agent's ability to set parameters correctly (e.g., including booking links, date format, and constraints).

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

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

The description uses a specific verb ('Fetch') and resource ('room-level availability, pricing, and amenities for a specific hotel') and clearly distinguishes from search siblings by emphasizing 'specific hotel' and 'stay dates'. It immediately communicates the tool's scope and differentiates it from the related skiplagged_sk_hotels_search.

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

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

The description provides clear context on when to use the tool (for a specific hotel and stay dates), implying it's for retrieving details rather than searching. However, it doesn't explicitly mention alternatives or exclusions, though the parameter description for 'hotelId' adds 'from search results' to guide sequencing.

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

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

With no annotations provided, the description carries the full burden. It does convey that the action is a search and states the broad response includes ratings and pricing. However, it does not disclose pagination behavior, city-matching limitations, or other operational constraints that are part of the parameter schema.

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

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

The description is a single clear sentence that front-loads the tool's purpose, action, and result. No redundant or unnecessary wording is present.

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 is adequate for a straightforward hotel search tool, especially since the schema covers all parameters richly. However, there is no output schema, and the description doesn't mention pagination, sorting, room/guest options, or how city matching works, so it is not fully self-contained for an agent.

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

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

Schema description coverage is 100%, so the schema itself already documents each parameter. The description adds only a high-level mention of city and dates, but does not provide additional meanings beyond what the input schema already states. Baseline of 3 is appropriate.

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

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

The description clearly states the action ('Search Skiplagged for hotels in a city') and includes the key parameters (check-in and check-out dates), plus the output context (ratings and pricing). It is more specific than a mere restatement of the tool name, though it does not explicitly differentiate itself from the sibling skiplagged_sk_hotel_details tool.

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

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

No usage guidance is provided. The description does not say when to prefer this search over hotel_details, flights_search, or other accommodation search tools, nor does it mention any prerequisites or exclusions. The intended use is only implied by the word 'search'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic transformation without explaining behavior such as normalization, partial matching, ambiguity handling, failure modes, or return 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 a single front-loaded sentence with no filler or repetition. It is concise and easy to scan.

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

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

For a simple single-parameter resolver, the description plus schema provide the core information. However, completeness is limited by the lack of output schema, no mention of return values, no error/edge-case behavior, and no guidance on how this differs from sibling lookup tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value by clarifying that 'input' is a city name, though the schema's phrase 'City name code' is slightly confusing and not clarified further.

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

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

The description uses a specific verb ('Resolve') and clearly identifies the input (city name) and output (valid IATA code). It differentiates from the sibling skiplagged_sk_resolve_location by explicitly specifying the output as an IATA code.

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 is provided on when to use this tool versus alternatives like skiplagged_sk_resolve_location, airports_lookup, or airports_search. There are no exclusions, prerequisites, or context hints about when a city name should be resolved this way.

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

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

The description notes that it takes no user-provided arguments but does not disclose the actual behavior beyond resolution, such as how the client location is obtained, potential failure modes, or privacy implications. With no annotations, this is insufficient transparency.

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

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

The description is a single, direct sentence that front-loads the core function and explicitly mentions the lack of arguments. No wasteful text or filler.

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

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

For a tool with no parameters and no output schema, the description covers the essential purpose but omits details about the client-supplied location source and output behavior. It could be more complete for an agent to invoke confidently, especially regarding what 'coarse location metadata' means and what the resolved airport output looks like.

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 zero parameters, and the description explicitly confirms that no arguments are needed. This matches the schema; no further semantics are required, and the description gives confidence that no hidden arguments exist.

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 resolves coarse location metadata to the nearest airport, using a specific verb and resource. It distinguishes itself from the sibling resolve_iata tool by focusing on coarse locations rather than IATA codes, though it doesn't explicitly name that sibling.

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

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

No usage guidance is provided regarding when to use this tool over alternatives like resolve_iata or airports_lookup. It does not specify prerequisites or context requirements beyond 'supplied by the client,' which is vague and leaves the agent unsure of when this tool is 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?

With no annotations, the description carries the burden of disclosing behavior. It states that the tool searches by name and returns matching operator IDs, which covers the basic read-only nature. However, it omits details like whether the search is exact/partial, how many results are returned, or what happens if no match is found.

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

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

The description is two concise sentences, front-loaded with the usage scenario and directly followed by the operational detail. 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?

For a simple one-parameter search tool with no annotations or output schema, the description provides adequate context: what it does, when to use it, what it returns, and how to use the result. It lacks some edge-case behavior (e.g., partial matches, result limits) but is largely complete for its 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?

The schema already fully documents the textSearch parameter with an example. The description adds context about the returned ID being used for tour filtering, but no new parameter-level semantics. Given 100% schema coverage, the baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: finding a tour operator's ID by name for filtering tours. It uses a specific verb ('find') and resource ('tour operator's ID'), and the context of 'filtering tours' distinguishes it from other tourradar search tools.

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

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

It explicitly states when to use the tool ('Use this when you need to find a tour operator's ID'), but does not mention when not to use it or provide explicit alternatives. The phrase 'for filtering tours' implies the alternative of searching tours directly, but this is not stated.

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

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

With no annotations provided, the description carries the full burden. It discloses support for multiple name variants (e.g., Krakow, Kraków, Cracow) which is helpful, but it does not describe search matching behavior, return format, or potential edge cases like no results.

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

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

The description is two sentences long, front-loaded with the primary use case, and contains no redundant or filler content. Every sentence contributes meaningful 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?

For a simple 2-parameter lookup tool, the description covers the core purpose and usage context adequately. It could improve by mentioning the expected output structure, but the absence of an output schema makes this less critical.

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

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

Schema description coverage is 100%, and the search parameter already provides detailed guidance including examples of passing name variants. The tool description adds minimal new parameter information beyond what the schema already states.

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 function: 'Searches for cities by name within a specific country' and explicitly ties it to finding city IDs for tour filter fields like start city, end city, or cities to visit. This specificity distinguishes it from sibling tour search 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?

The opening sentence gives explicit usage guidance: 'Use this when you need to find city IDs for tour search filters...' It does not name alternatives, but the use case is clear enough 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?

With no annotations provided, the description carries the burden of disclosing behavior. It accurately describes a read-only list operation and mentions the output fields (IDs and names). However, it does not mention any limitation, auth requirements, or data format details, which are minimal for a simple list but still a slight gap.

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 exceptionally concise: two short sentences with no filler. It front-loads the usage guidance and then states the output, making it easy to parse quickly.

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

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

For a simple no-parameter list tool, the description fully covers what it does, when to use it, and what it returns. There is no output schema, but the description explicitly lists the return content (IDs and names), making it 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 tool has zero parameters, so the baseline is 4. The description adds context by noting the output is intended for use in tour search filters, which gives semantic meaning even without parameters.

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

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

The description clearly states the tool returns a list of supported continents with their IDs and names. It uses a specific verb ('Returns') and identifies the resource (continents list), distinguishing it from sibling tools like countries-list or cities-search.

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 when you need continent IDs for filtering tours by region,' providing clear usage context. It does not explicitly mention when not to use it or alternative tools, but the context is sufficient for this simple lookup 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly states that the tool returns a complete list with IDs, names, and ISO codes, which effectively communicates the read-only, informational nature. It does not mention potential pagination or data freshness limitations, but for a simple list endpoint this is adequate.

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

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

The description is two short sentences, front-loaded with the use case and followed by a concise description of the return value. Every word adds value, with no redundancy or filler.

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

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

For a parameterless, list-returning tool, this description is complete. It covers the purpose, the trigger conditions, and the exact shape of the returned data (IDs, names, ISO codes). No output schema exists, but the description supplies the essential return information.

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

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

The tool has zero parameters, so the description doesn't need to explain parameters. It does add context about the output fields (IDs, names, ISO codes) which is useful beyond the empty input schema. This aligns with the baseline for no-parameter 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 the tool's purpose: looking up country IDs and validating country names. The verb 'look up' plus the resource 'country IDs' is specific, and the mention of returning a country list distinguishes it from other lookup/list sibling 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?

The description explicitly says when to use the tool ('when you need to look up country IDs for filtering tours or validating country names'). It does not provide explicit when-not-to-use instructions or alternatives, but the use case is clear and sufficiently targeted.

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

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

With no annotations, the description carries the burden of disclosing behavior. It clearly states that it 'Returns a list of all supported currencies' with specific attributes, which implies a read-only, non-destructive operation. It doesn't mention rate limits or errors, but for a zero-parameter list, this is adequately transparent.

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

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

The description is two sentences, front-loaded with the use case and immediately followed by the return value details. Every sentence adds value, with no redundant 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?

For a zero-parameter, no-output-schema list tool, the description fully covers what the agent needs: when to use it and what to expect in the response (codes, names, symbols with examples). It is complete for its simplicity.

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

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

The tool has zero parameters, and the schema is an empty object with 100% coverage. According to the rubric, zero-parameter tools get a baseline of 4. The description adds no parameter info because there are no parameters to describe, which is appropriate.

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

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

The description clearly states the tool's purpose: to check supported currencies and get currency details like symbols. It distinguishes itself from sibling list tools (cities, countries, languages) by its specific focus on currencies.

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 an explicit 'when to use' ("Use this when you need to check supported currencies or get currency details like symbols"), but does not mention alternatives or when not to use. For a simple list tool, this is sufficient guidance, but it lacks explicit exclusions.

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

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

With no annotations, the description must convey behavioral traits. It discloses that the tool returns a list with IDs, codes, and names, and implies the operation is read-only. However, it does not mention any additional behavior such as response format, pagination, or errors, but for a simple list endpoint this is adequate.

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

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

The description is two sentences: the first states when to use the tool, the second states its output. Every word is purposeful, with no redundancy or filler. It is front-loaded with the tool's key 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?

The tool is simple: no parameters, no output schema, and a straightforward listing purpose. The description fully explains why you would use it (to get language IDs for filtering) and what it returns (IDs, codes, names). This is complete given the tool's 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?

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter semantics, and the schema already confirms no parameters exist. The description adds no parameter information because none is needed.

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 returns a list of all supported languages with their IDs, codes, and names. It uses a specific verb ('Returns a list') and a specific resource ('supported languages'), and its purpose—supporting tour search filters—is unambiguous. It is clearly distinguished from sibling list tools by focusing on languages.

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 when you need language IDs for filtering tours by guide language,' giving a clear use case. It does not mention when not to use it or alternatives, but the context is sufficient for a simple lookup 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?

Since annotations are absent, the description carries the full burden for behavioral disclosure. It only says 'fetches operator details,' implying a read-only operation, but it does not explicitly state that, nor does it mention any side effects, error behavior, or special requirements beyond an operator ID. This is a minimal disclosure for a tool with no annotation support.

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

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

The description is two sentences, front-loaded with the use case, and every sentence adds value. There is no fluff or repetition of schema details, making it appropriately concise and well-structured.

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

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

For a simple 1-parameter tool with no output schema, the description covers the purpose, when to use, and gives a glimpse of the output fields ('name, code, and terms & conditions'). It is mostly complete, though it could mention edge cases (e.g., invalid operator ID) or explicitly confirm the read-only nature. Overall, it is sufficient for the tool's simplicity.

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

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

The description adds meaning by saying fetch details are 'based on operator ID,' which clarifies the role of the sole parameter. However, with 0% schema description coverage, it does not fully compensate by explaining the ID format or its origin (e.g., from a search tool). It does list the returned details, giving some context, but the parameter semantics are only partially covered.

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 fetches operator details (name, code, terms & conditions) based on operator ID, using a specific verb ('fetches') and resource. It distinguishes itself from sibling tools like tourradar_algolia-operator-search, which is for searching operators, by focusing on retrieving details for a specific operator.

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 first sentence gives explicit usage context: 'Use this when the user wants information about a tour operator, such as their terms and policies.' This is clear, but it does not mention when not to use it or explicitly reference alternative tools, so it misses the full 'when-not' guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses the return content (availability, pricing, booking info) but does not mention whether the operation is read-only, any permissions required, pagination behavior, or potential limitations. It is adequate but not rich.

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: two sentences with the usage context front-loaded. 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?

With no output schema, the description partially explains the return values (list of departures with availability, pricing, booking info). It covers the primary use case but omits pagination details and any edge-case behaviors, leaving minor 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?

All parameters have descriptions in the schema (100% coverage), so the baseline is 3. The tool description reinforces the use of tourId and dateRange but does not add new syntactic or format details beyond the schema. The page parameter is not mentioned in the description.

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

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

The description clearly identifies the tool as returning a list of departures for a tour, with specific capabilities (availability status, pricing, booking info). It mentions a date range and distinguishes this from other tourradar tools like tour details, FAQs, or 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?

The description explicitly states when to use the tool: when a user asks about departure dates, pricing for specific dates, or validating availability. However, it does not explicitly name alternatives or provide 'when not to use' guidance, so it falls short of a perfect score.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation via 'Fetches' and lists the output categories, but it omits prerequisites (e.g., where to obtain a valid tourId), error/not-found behavior, and any B2B-specific access constraints hinted at by the tool name.

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

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

The description is two short sentences, with the use case front-loaded and the content list concise. Every word earns its place; there is no filler or redundant 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?

For a simple fetch-by-ID tool, the description covers the main purpose and primary output categories. However, without an output schema and with only partial parameter documentation, it does not explain response structure, the optional currency parameter (though the schema covers it), or how to obtain a tourId, leaving some gaps for the agent.

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

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

Schema description coverage is only 50%; tourId has no description in the schema. The description merely restates 'based on tour ID' without adding guidance on how to find or validate a tour ID, while currency is already well-documented in the schema and receives no added context.

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

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

The description uses a specific verb ('Fetches') and clearly identifies the resource ('comprehensive tour details' for a specific tour), listing key content categories (itinerary, pricing, operator info, images, booking links). This clearly distinguishes it from sibling tools such as tour-departures, tour-faq, or tour-map.

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 'Use this when the user wants to see detailed information about a specific tour,' providing clear context for when to invoke the tool. It does not name alternatives or exclusions, but the directive is unambiguous and sufficient for 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It mentions pagination ('paginated list') and the content coverage (inclusions, requirements, policies), which is helpful. However, it does not disclose authentication needs, error behavior, or response structure, which are relevant for an API tool.

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

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

The description is two sentences: a usage trigger and a result summary. No unnecessary details, front-loaded with the key use case. Very concise and well-structured.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the main aspects: when to use, what it returns (paginated FAQ list), and topic focus. It does not outline exact response fields, but that is not essential for this type of lookup tool. It is fairly complete for its context.

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

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

Schema description coverage is only 50% (page is described, but tourId is not). The description adds minimal semantic value for parameters: 'about a specific tour' implies tourId but does not explain it, and the page parameter is not mentioned at all. The description does not compensate for the missing schema documentation.

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

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

The description clearly states the tool returns a paginated list of frequently asked questions and answers about a specific tour. It uses a specific verb ('Returns') and a resource ('FAQ section'), and the context about user questions distinguishes it from sibling tools like tour details or departures.

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 an explicit when-to-use instruction: 'Use this when the user has questions about a tour that might be answered in the FAQ section.' It does not mention alternatives or exclusions, but the usage context is clear and actionable.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that it 'fetches tour details' and 'prepares map data,' which implies a read-only operation but does not disclose details like output format, potential errors, or rate limits. The description adds some behavioral context but is not comprehensive.

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 two sentences that are front-loaded with the use case. Every word serves a purpose; no filler or redundant 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 gives a solid overview of the tool's behavior and output ('map data with all itinerary locations, coordinates, and day-by-day information'). While it lacks explicit output schema details, the description is adequate for an agent to understand what to expect and when to use it, especially given the simplicity of the tool.

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

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

Schema description coverage is 50%, with only 'currency' documented. The description mentions 'one or more tours,' which aligns with the required 'tourIds' parameter, but it does not explicitly explain what tourIds are or how to provide them. Currency is described in the schema, and the description adds no extra meaning. Baseline of 3 is appropriate given the partial coverage and marginal additional context.

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

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

The description clearly states the tool's function: showing tour routes on a map and comparing itineraries visually. It uses specific language ('see tour routes on a map', 'compare itineraries visually') that distinguishes it from sibling tools like tour-details or tour-search which serve different purposes.

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 first sentence provides explicit guidance on when to use this tool: 'when the user wants to see tour routes on a map or compare itineraries visually.' This gives clear context, though it does not explicitly list when not to use it or name alternative 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?

With no annotations, the description carries the full burden. It discloses the return structure as a hierarchical list of groups and types with IDs and names. For a simple read-only list tool, this is sufficient; it doesn't hint at side effects or errors, but none are expected.

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

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

The description is two sentences: the first gives an immediate usage directive, and the second succinctly summarizes the output. Every sentence earns its place, with no redundancy or 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 the tool's low complexity (0 params, no output schema), the description adequately covers purpose and return type. Minor gap: it doesn't specify whether the hierarchy is always full or if it can be filtered, but for a list tool this is sufficient.

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 is empty. Per the baseline for 0-param tools, a score of 4 is appropriate. The description doesn't need to explain parameter semantics since there are none.

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

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

The description uses a clear verb 'Returns' and specifies the resource: a hierarchical list of tour type groups with individual types, IDs, and names. This clearly distinguishes it from sibling list tools like continents-list or countries-list by focusing on tour types for filtering.

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 'Use this when you need tour type IDs for filtering tours by category' providing a clear trigger condition. It does not mention exclusions or alternatives, but the guidance is specific enough for an agent to select it for tour-type lookups.

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

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

With no annotations, the description carries the full burden. It clearly states the output format (ISO) and action (returns current date/time). It does not mention timezone or that it is a safe read-only operation, but for a date utility this is quite transparent.

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

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

Two sentences, front-loaded with the primary use case and output format. Every sentence adds value 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 zero-parameter utility tool with no output schema, the description fully covers purpose, usage, return format, and relevancy to tour searches. Nothing essential is missing.

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

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

The tool has zero parameters, so no parameter explanation is needed. The baseline for 0 params is 4, and the description correctly avoids wasting space on parameter details.

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

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

The description states a clear action: 'Returns the current date and time in ISO format.' It identifies the resource (current date) and is distinct from sibling tools like tour search or booking tools. It also provides a specific use case context.

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 guidance on when to use: 'Use this when you need to know the current date, especially before setting departure date filters.' It does not mention alternatives, but there is no obvious alternative sibling for this simple utility, so the context 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?

With no annotations, the description carries the full burden. It discloses key behaviors: AI-powered semantic search, the requirement for tourIds, and the optional text query for topic filtering. It doesn't mention output format or pagination behavior, but for a read-only search tool this is adequate context. The note about combining with a query adds useful behavioral detail beyond structured fields.

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 compact and front-loaded. The first sentence states the core purpose. Each subsequent sentence adds essential context: requirement, when to use, how to combine query, and fallback to sibling tools. No filler or repetition — every sentence earns its place.

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

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

For an 8-parameter tool with no output schema, the description provides sufficient context: purpose, required scope, usage timing, and alternatives. It doesn't cover pagination or default sorting, but the schema fully documents parameters. The tool description is complete enough for an agent to select and invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra value by explaining that the query should be 'short natural language', providing concrete examples ('food', 'guide', 'accommodation'), and explicitly recommending the 'keywords' parameter when topics are known. This reinforces and clarifies the schema without being redundant.

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 tour reviews using AI-powered semantic search.' It specifies the resource (tour reviews), the action (search), and the key constraint (requires tourIds to scope results). This distinguishes it from sibling tools like vertex-tour-search and vertex-tour-title-search, which are explicitly named as alternatives for finding tours first.

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

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

The description provides explicit when-to-use guidance: 'Use this when the user asks about reviews, feedback, or experiences for specific tours.' It also gives clear alternatives: 'When you don't have tour IDs, use vertex-tour-search or vertex-tour-title-search first to find them.' This is strong, actionable usage context.

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

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

With no annotations, the description must carry the full transparency burden. It discloses that the tool uses Google Vertex AI to understand intent, supports semantic search, and returns a list of tours with ID, name, URL, operator, and description. It also mentions performance characteristics ('to make search faster') and covers display modes. However, it does not mention edge cases like empty results or error behavior, which slightly lowers the score from a 5.

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

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

The description is well-structured with headings, tables, and examples, and it is front-loaded with usage guidance. However, it is quite long and repetitive, with filter details duplicated from the schema and multiple examples that could be condensed. Every sentence does not earn its place, so it is not a model of conciseness.

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

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

Given the tool's high complexity (19 parameters, nested objects, no output schema), the description is thorough: it covers the required `textSearch`, optional filters across location, range, and AND/OR categories, provides comprehensive examples, and describes the response format. It references auxiliary tools like `b2b-cities-search` for IDs and explains the display modes. Minor gaps (e.g., no mention of pagination or result limits) prevent a 5.

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 95%, so the schema already provides rich descriptions for most parameters, earning a baseline of 3. The description adds a consolidated filter table and examples that clarify usage (e.g., age range examples for family-friendly tours), but much of this duplicates schema text. It does not add substantial new semantics beyond the schema, so a 3 is appropriate.

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

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

The description clearly states the tool performs AI-powered semantic search for tours using natural language queries with optional filters. It explicitly names the tool (`vertex-tour-search`) and distinguishes it from sibling tools like `tourradar_vertex-tour-title-search` and `tourradar_vertex-review-search` by focusing on natural-language intent understanding. The phrase 'Use `vertex-tour-search` when...' further reinforces its specific purpose.

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

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

The description provides explicit when-to-use guidance with bullet points ('Use `vertex-tour-search` when: the user describes what they want in natural language', etc.) and strongly encourages filter usage to improve speed and precision. It lacks explicit when-not-to-use or alternative tool references, but the context is clear enough for an agent to distinguish this from other search 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?

No annotations are provided, so the description carries the full burden. It discloses the semantic search nature and the return format (IDs and titles), which is useful. However, it doesn't mention any nuances like behavior on no matches, result ordering, or limits. This is adequate but not rich.

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

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

The description is two sentences, front-loaded with the core function, and includes a follow-up usage note about an alternative tool. Every sentence earns its place; there is no redundancy or 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 one-parameter search tool, the description covers the purpose, output, and usage context, and points to an alternative. It doesn't have an output schema, but it does say what will be returned. Missing minor details like result count or ordering, but overall complete for the tool's 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?

Schema coverage is 100% for the single parameter, and the schema describes it as 'Tour title or partial title to search for.' The description repeats 'by title' and doesn't add extra meaning beyond the schema, such as example formats or matching rules. The baseline of 3 applies because the schema already covers the parameter.

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

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

The description clearly states the tool's function: 'Search for tours by title using AI-powered semantic search' and specifies the output ('matching tour IDs and titles'). It distinguishes itself from the b2b-tour-details tool by explicitly pointing to the alternative when a tour ID is known, and the focus on title-based lookup differentiates it from other search tools.

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

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

It provides explicit when-to-use guidance: 'Use this when you need to look up a tour by name.' It also names an alternative for a different scenario: 'When you know tour id, use b2b-tour-details tool.' This is clear and actionable.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses that no booking is created, that omitting departureDate lets the backend pick the nearest departure, and that user data must be real. However, it does not mention side effects like sending an inquiry to the operator, rate limits, or authentication requirements.

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: a purpose sentence, mode breakdown, and user-data rules. Every section is useful, and the bullet-like layout aids scanning, though it does repeat some schema 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 no output schema and no annotations, the description covers most necessary context: modes, required IDs, optional date behavior, and data integrity rules. The main gap is what the tool returns or confirms after sending the question, but for a submission-style tool this is not a critical omission.

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

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

The input schema already describes all parameters (100% coverage), but the description adds valuable semantics: it clarifies the entity modes, explains that departureDate is optional and should not be fabricated, and emphasizes using real contact details. This goes beyond the schema's property 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 explicitly states 'ASK A QUESTION about a tour or operator WITHOUT committing to a booking,' which names the verb (ask), resource (tour/operator), and constraint (no booking). This clearly distinguishes it from sibling tools like booking or search 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?

The description opens with 'Use this when...' and details two modes (tour vs operator) with required IDs. It also includes exclusions ('WITHOUT committing to a booking') and data-handling rules, though it does not explicitly name alternative 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?

With no annotations provided, the description must carry the burden of behavioral disclosure. It goes beyond the basic action by emphasizing that real contact details are required, that the agent must never fabricate or assume user data, and that missing information should be asked for. This adds valuable operational constraints beyond the schema, though it does not describe post-creation behavior or side effects.

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 four sentences, front-loaded with the usage condition, and every sentence adds necessary context: action, prerequisites, confirmation step, and anti-fabrication warning. No wasted words.

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

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

For a write tool with 10 parameters and no output schema, the description covers when to use, required data, a critical prerequisite (check departures), and behavioral guardrails. It could be more explicit about the nature of a 'booking request' (e.g., that it's not a final booking), but overall it is quite complete for the given 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?

Schema description coverage is high (80%), so the schema already documents most parameters. The description adds a general requirement for 'real contact details (email, names; phone optional)' and stresses to ask for missing info, which complements the schema but does not significantly add per-parameter semantics beyond what's already present.

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 ('Creates a booking request') and the resource ('a specific tour'), and specifies the triggering condition ('when the user explicitly wants to book a tour and has provided their contact details'). This distinguishes it from sibling tools like tourradar_web-ask-question or tourradar_web-tour-send-brochure.

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 when to use the tool ('when the user explicitly wants to book a tour and has provided their contact details') and provides a procedural guideline ('Always confirm the departure date by checking departures first'). It does not explicitly mention when not to use or name alternative tools, which keeps it just short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool sends a PDF and explicitly states a key behavioral constraint: never generate or assume email addresses, which adds useful context. However, it does not describe potential side effects such as what happens if the tourId is invalid, whether the email could fail, or what response/confirmation the user should expect. This is a moderate level of transparency, but gaps remain.

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 and front-loaded. The first sentence immediately states the trigger condition, and the second paragraph provides the essential behavioral detail in two short sentences. There is no redundant or filler content. Every sentence earns its place, making it easy for an agent to parse quickly.

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

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

Given the tool's low complexity (2 parameters, no nested objects, no output schema) and the rich schema descriptions, the description provides a complete-enough picture for an agent to invoke it. It covers the purpose, the email collection workflow, and the action taken. However, it lacks information about what happens after sending (e.g., success confirmation or error handling), which would be helpful since there is no output schema to clarify 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?

The input schema already provides 100% coverage of both parameters with detailed descriptions: 'email' includes format, pattern, and instruction to ask the user if not provided; 'tourId' is described as required with constraints. The tool description adds little beyond reinforcing the email requirement, which is already in the schema. Since schema coverage is high, the baseline is 3, and the description does not significantly augment the schema's information.

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 sends a tour brochure (PDF) to a specified email address using the precise verb 'sends' and resource 'tour brochure (PDF file)'. The leading phrase 'Use this when the user requests a tour brochure or PDF to be sent to their email' precisely identifies the trigger, distinguishing it from sibling tools like tourradar_web-tour-booking or tourradar_web-ask-question.

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 when to use the tool: 'Use this when the user requests a tour brochure or PDF to be sent to their email.' It also provides clear prerequisites and handling instructions: ensure the user has provided their email, ask if not, and never generate or assume email addresses. However, it does not mention when not to use it or name alternative tools, so it misses the 'when-not' component of a top score.

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

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

With no annotations, the description carries the full burden. It discloses that the tool routes automatically and returns a combined answer, but it does not mention potential side effects, whether it only performs read-only actions, or any limitations (e.g., not booking directly). This is adequate but not rich.

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

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

Two sentences plus an example convey the entire purpose and usage. No redundant text, efficient and front-loaded.

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

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

For a simple tool with one parameter and an output schema, this description is largely complete. It gives the behavioral model, an example, and implies coverage across multiple travel domains. Missing details about error handling or latency are minor for an agent tool.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that 'query' should be a natural-language travel question and provides a concrete example ('Cheapest flights from Zurich to Rome next week, and do I need a visa?'), adding meaning beyond the bare parameter name.

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 is a natural-language travel agent that routes to the right tools and returns a combined answer. This distinguishes it from the many specialized sibling tools (e.g., skiplagged_sk_flights_search, visa_check) by framing it as an orchestrator.

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

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

The description tells users to ask a travel question in natural language, implying this tool is the entry point when you don't know which specific tool to call. It doesn't explicitly state when not to use it or name alternatives, but the routing behavior and example effectively convey the intended 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?

No annotations are provided, so the description carries the behavioral burden. It adds useful behavioral facts: results are live, aggregated via metasearch, and equivalent to trivago-accommodation-search output. However, it does not disclose result limits, pagination, ordering, or other operational behaviors, leaving a moderate gap for a search tool with no annotations.

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

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

The description is two sentences with no filler. It front-loads the tool's purpose, then immediately provides the decision rule and sibling distinction. Every sentence contributes selection-relevant 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?

For a 14-parameter tool with no output schema, the description is largely sufficient: it states the coordinate-based scope, the exact data source, and the expected result equivalence with the sibling tool. The input schema covers all parameters and constraints. It would be more complete with explicit output shape details, but the sibling reference handles the main expectation.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents each parameter. The description's mention of landmarks, addresses, venues, and neighborhoods reinforces the latitude/longitude semantics but adds no meaning beyond what the schema already states.

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 a specific action and resource: 'Search live hotel and accommodation listings near specific coordinates.' It clarifies the scope (landmark, address, venue, neighborhood) and differentiates itself from trivago-accommodation-search by the coordinate-anchored versus named-destination distinction.

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

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

It explicitly says when to use this tool: 'Use when the user anchors their search to a place rather than a named destination,' and gives concrete examples like 'near the stadium.' It also names the sibling tool and notes it returns the same result set, which routes the agent to the correct alternative without 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?

With no annotations, the description carries the full behavioral burden, and it does well: it notes the search is 'live,' aggregated via trivago metasearch, and that results include price, rating, amenities, and a link per property. It also summarizes supported configurations and filters. It stops short of describing pagination, result limits, or response structure, but still gives useful behavioral 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 three compact sentences with no filler: it states what the tool does, what results look like, and what configurations are supported, then gives a clear use-case. The Additional Information block is context metadata rather than redundant prose.

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

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

For a complex 13-parameter tool with no output schema, the description gives a solid high-level picture, including return content (price, rating, amenities, link) and supported options. It is complete enough for correct invocation, though it does not detail result ordering, pagination, or error behavior.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains every parameter. The description adds a helpful high-level grouping (date range, guest/room configuration, filters) but does not add per-parameter 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 opens with a specific verb and resource: 'Search live hotel and accommodation listings' and clarifies scope as 'by destination or point of interest.' It also closes with an explicit use case, 'Use for destination- or place-name-based lodging search,' which distinguishes it from the radius-based sibling tool.

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

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

The description clearly states when to use the tool: for destination- or place-name-based lodging search. It does not explicitly name the sibling radius-search tool or state when not to use this one, but the use-case phrasing provides enough context for an agent to route correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds a valuable behavioral trait by clarifying this is a forecasting tool rather than a live-availability search, and it states what kind of statistics are returned. It does not disclose data freshness, forecast horizon limits, or what happens for unsupported destinations, leaving notable gaps.

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

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

Two sentences deliver purpose, output summary, usage examples, and a key exclusion without redundancy. The most important scoping information (forecast vs live availability) appears early, and the additional current-date context is compactly attached.

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 7-parameter, nested-object tool with no output schema and no annotations, the description covers the main return dimensions and the core use case. The schema handles parameter details, and the current date context helps with default month behavior. It is slightly shy of complete because it does not clarify the forecast date range or limitations, but it is broadly sufficient.

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

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

Schema description coverage is 100%, so the schema already documents all parameters in detail, including defaults and allowed formats. The description's mention of destination, star rating, and date window maps to query, hotel_rating, and start_month/end_month but adds no 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?

Uses a specific verb ('Forecast') and resource ('monthly hotel price trends for a destination') and details the output scope (average/minimum/maximum nightly rate by star rating, across a date window). It explicitly contrasts itself with live-availability search, distinguishing it from the sibling trivago accommodation search 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?

Provides clear when-to-use guidance with concrete example questions ('when is the cheapest month to visit X') and an explicit exclusion ('not a live-availability search'). However, it does not name the sibling alternative to use for live-availability searches, so it stops short of fully explicit routing.

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