Camping Australia

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

Annotations only flag mutation/non-idempotent/non-destructive; the description adds the non-obvious server-driven state machine, the 'added' vs 'question_pending' status values, and the requirement to reuse session_key. It stops short of describing duplicate-add behavior, error modes, or other return fields, which matters since no output schema exists.

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

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

Front-loads the core purpose and then uses bullets that each carry procedural weight. It is fairly long and dense with no quick-scan summary line, but almost no sentence is filler.

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

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

For a complex 10-param, nested-object, stateful tool with no output schema, the description covers the critical loop and status outputs well. It leaves out what a successful 'added' response returns (cart contents, next step), which the absent output schema would otherwise need to carry.

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 already 100%, but the description adds genuine value by clustering parameters by call mode (first-add set vs. answer set with answer={field_id, value}). It does not explain oddities like why all 10 params are non-required.

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

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

States a specific verb and resource ('Add a product to the live booking cart') and immediately disambiguates the dual purpose ('OR answer a booking question'). This cleanly separates it from siblings like bk_cart_checkout and bk_cart_promo.

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 prescribes the two modes: omit session_key for a first add with a listed param set, or supply session_key + pending_token + answer to resolve a pending question. It also directs the agent to source product_id/operator_id/quoted_price from bk_operator_availability, leaving little to inference.

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

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

Annotations declare a non-readonly, destructive mutation but say nothing about the two-phase behaviour. The description adds rich context beyond them: the no-confirm branch returns summary+total with NO payment link, the confirm branch yields the payment link, and the booking stays 'pending until they pay.' It also notes the checkout URL covers the whole cart, which is meaningful scope information for a destructive operation.

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

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

Front-loaded with purpose and the two numbered steps, so the critical flow is easy to scan. It is somewhat verbose: the trailing UI instructions ('label the link Book now,' 'never name the booking platform') are peripheral to the tool's invocation contract and dilute the core message.

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

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

With no output schema, the description compensates fully by specifying what each branch returns (summary + total vs. secure payment link) and the post-call state ('pending until they pay'). Combined with the setup precondition, an agent has everything needed to call this correctly.

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

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

Schema description coverage is 100%, so the schema already documents both confirm and session_key, making 3 the baseline. The description goes slightly beyond the schema by framing confirm as a human-in-the-loop gate (only after explicit agreement) rather than just a boolean flag, giving the agent the rationale for setting it.

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

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

States a specific verb (finalise) and resource (live booking cart / checkout URL), with the outcome made concrete: 'get the SINGLE checkout URL the user uses to complete payment.' It is trivially distinguishable from the cart-manipulation siblings like bk_cart_add, bk_cart_guest, and bk_cart_promo.

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

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

Gives explicit preconditions ('Only call once the cart is ready (no pending questions) and bk_cart_guest has set the lead guest') and a clear two-step invocation protocol specifying exactly when to call without confirm and when to call with confirm=true. It even states the forbidden action (never set confirm=true yourself).

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

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

Annotations declare a non-readonly, non-destructive, non-idempotent write, and the description adds the important behavioral fact that omitted fields are prefilled from the account for signed-in customers, plus the hard requirement of name and email to issue a booking. It does not state whether a second call replaces or merges prior values, which matters given idempotentHint=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?

Three tight sentences, front-loaded with what the tool does, then the requirement, then the call-ordering rule. No filler or restatement of the name/title.

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

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

With no annotations covering return behavior and no output schema, the description handles the important operational context: prerequisites, ordering relative to checkout, and prefill behavior. The required-vs-optional mismatch with the schema leaves a small ambiguity about whether the call can actually succeed with only session_key.

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 and the schema already documents each field's meaning. The description adds useful override/prefill semantics for first_name, surname, and email, but it conflicts with the schema, which marks all three as required while the description says they may be omitted and prefilled.

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

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

States a specific verb and resource: attach the lead guest's contact details to the live booking cart. This clearly distinguishes it from bk_cart_add, bk_cart_promo, and bk_cart_checkout without opening any schema.

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

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

Gives explicit sequencing ('call once the cart has items and before bk_cart_checkout') and states the two invocation modes: call with just session_key for a signed-in customer, or pass explicit values to override. The condition that selects each behavior is spelled out.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent, closed-world behavior, so the safety profile is covered. The description adds useful context beyond that: it operates on the 'live booking cart', it must run before checkout for the total to reflect, and remove=true strips a code. No contradiction with destructiveHint=false, since removing a cart code is not a destructive operation.

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

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

Three short sentences, zero filler, with the purpose front-loaded before the trigger and the remove flag. Every sentence carries distinct 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 3-parameter cart mutation with no output schema and full annotation coverage, the description supplies what's needed: purpose, trigger, sequencing, and the remove path. The only minor gap is the resulting cart state after applying an invalid or expired code, which is left unaddressed.

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

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

Schema description coverage is 100%, so all three parameters (session_key, promo_code, remove) are already documented. The line 'Set remove=true to take a code off' largely restates the schema's own description of the remove flag rather than adding new syntax or constraints, so baseline 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?

States a specific verb pair (apply/remove) and resource (promo/discount code) scoped to the 'live booking cart', which cleanly separates it from bk_cart_add and bk_cart_checkout. An agent can tell what it does and does not do without opening the schema.

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

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

Gives a clear trigger ('when the user gives a promo code') and sequencing guidance ('call before bk_cart_checkout so the discounted total shows'), which is genuinely useful for a cart workflow. It stops short of naming when-not conditions or alternatives, but the ordering constraint is explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false, so safety and idempotency are covered. The description adds that data is LIVE and the return shape, but says nothing about rate limits, staleness, or failure modes for an external live-data call.

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

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

Three sentences, zero waste. Purpose is front-loaded, return fields are enumerated, and the sequencing instruction is last, which is the correct order for an agent skimming top-down.

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

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

Covers purpose, inputs, output shape, and sequencing for a 5-param read-only tool with no output schema and full schema coverage. Slightly short of 5 because it does not mention any latency, caching, or freshness caveats that matter for a LIVE external availability call.

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 all five parameters are fully documented in the schema. The description mentions operator_id provenance, which mirrors the schema's own note, and adds no format or constraint details beyond what the schema provides. 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?

States a specific verb (Get), resource (LIVE products, pricing and availability), scope (for a live-bookable operator for specific dates), and enumerates the returned fields. This clearly distinguishes it from bk_search_operators (search) and bk_cart_add (mutation).

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

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

Explicitly routes the agent: 'Call this (using an operator_id from bk_search_operators) before bk_cart_add.' Both the prerequisite source and the next step are named, leaving no ambiguity about when to use this tool versus siblings.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely non-structured context: the content is sourced from an external booking partner and is explicitly NOT duplicated in the operator's own directory, which matters for trusting results. It stops short of describing result shape or matching behaviour.

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

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

Three tight sentences, front-loaded with purpose before the positive/negative usage rules. No filler, no repetition of what the schema or annotations already state.

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 two-parameter read-only search with no output schema, an agent has everything it needs to invoke correctly: query intent, scope, exclusions, and the provenance caveat. Only a brief note on what results look like is absent, which is a minor gap given no output schema exists.

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%, including a worked example ('things to do near Jervis Bay'), so the schema already carries the parameter meaning. The description adds no syntax, format or default-value detail beyond that, which is the baseline expectation when the schema is fully documented.

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

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

States a specific verb and resource plus the content domain: 'Search curated tourism content (attractions, things to do, local experiences, events) from our booking partner.' It explicitly distinguishes itself from the accommodation siblings, so an agent can pick it without opening a schema. The misleading title ('Caravan park booking info') is a naming flaw, but the description text itself is unambiguous.

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

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

Gives a concrete trigger ('what's on / things to do near X' style questions) and an explicit exclusion (NOT for campsite/accommodation booking), which is strong routing guidance. It loses a point for gesturing at 'the other bk_ tools' collectively rather than naming the actual alternative such as bk_search_operators or search_campsites.

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

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

Annotations already cover readOnly/idempotent/non-destructive safety, so the bar is lower. The description adds genuinely useful context beyond that: real-time inventory via a live booking partner and the fact that returned operator_id values are consumed by other bk_ tools. It stops short of rate limits or auth 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?

Front-loads the core purpose, then usage routing and return-value chaining. Slightly repetitive with the capitalized DIFFERENT plus the parenthetical, but every sentence carries useful information and nothing is padded.

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

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

There is no output schema, yet the description supplies the key return contract (operator_id values that feed other bk_ tools). Combined with the safety annotations and full schema coverage, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents latitude, longitude, limit, and within_km with defaults and ranges. The description only implies location-based search and adds no syntax or format detail beyond what the schema already provides, so baseline 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?

States a specific verb (find) and resource (live-bookable accommodation operators) with scope (near a location, via live booking partner). It explicitly distinguishes itself from search_campsites and names the sibling it is not, so an agent can route without opening any schema.

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

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

Gives explicit when-to-use triggers ('book', 'reserve', 'is it available', 'real prices for specific dates'), names the alternative (search_campsites) and the condition that selects it. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful behavioral context such as the data source (National Public Toilet Map), sorting by distance, the fields returned, and the fallback behavior when no toilets are within radius. This goes beyond the annotations and helps set expectations.

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 efficiently structured: first sentence states the core purpose, followed by use-case examples and return details. The second paragraph addresses a key ambiguity around location handling. No redundant or filler content exists; every sentence serves a purpose.

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

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

The tool is relatively simple with no output schema, but the description covers return fields, sorting, and filtering behavior. It also addresses the common 'near me' scenario. Minor gaps exist such as error handling for invalid coordinates or exact pagination, but overall this is sufficiently complete for effective use.

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

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

Schema description coverage is 100%, so parameters are already documented. The description adds extra semantic value by explaining how latitude/longitude should be derived from user context or conversation, and notes default values for limit and radius. This supplements the schema descriptions meaningfully.

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: 'Find the nearest PUBLIC TOILETS to a location'. It clearly distinguishes from sibling tools like search_campsites or get_campsite_details by focusing on toilets. The example queries further clarify the tool's 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 explicitly states when to use the tool ('Use this for questions like...') and provides concrete example phrases. It also gives guidance on how to handle 'near me' queries, either passing known context or asking for location. It lacks explicit exclusions or comparisons to alternatives, but the context is clear enough for correct selection.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds useful context beyond annotations by specifying the exact return fields (pricing, capacity, amenities, vehicle access info) and the 'all' scope, which helps set expectations without contradicting the annotations.

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

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

The description is a single, well-structured sentence that front-loads the core purpose before adding examples and return details. Every clause adds value, and 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?

The tool is simple with one parameter and a clear read-only intent. The description includes what the tool returns, which is sufficient given there is no output schema. It does not explain pagination or response format, but for a list operation this is acceptable.

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

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

The schema documents the single parameter entity_id with a description matching the tool description. Description adds no new meaning beyond the schema, so with 100% schema coverage, 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 the tool lists accommodation types for a specific entity, with concrete examples (powered sites, unpowered sites, cabins, hotel rooms). It also lists the returned info, distinguishing it from sibling tools like get_campsite_details by focusing specifically on accommodation types.

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 indicates when to use the tool: when you have a specific entity_id and need the accommodation types offered by that entity. It does not explicitly name alternatives or exclusion criteria, but the context is clear enough for an agent to select it over siblings that do different things.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond this: the user finishes booking on DriveAway's site (no payment taken here), the tool returns a single booking_url, and it is Australia-only. This clarifies the external-redirect nature and geographic scope.

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 only two sentences, front-loaded with the core purpose, followed by essential usage notes and a constraint. Every sentence adds value with no redundancy.

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

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

Given the tool's simplicity, the description covers purpose, usage, return value, payment handoff, and geographic scope. The schema documents all params, and annotations cover safety. Missing details like error handling or unsupported cities are minor for this use case.

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 parameter context ('pickup city and dates') but does not elaborate on optional parameters like driver_age or passengers. The schema already provides sufficient detail for all 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 explicitly states the tool gets a DriveAway booking deep-link for campervan/motorhome hire given a pickup city and dates. It uses a specific verb ('Get') and resource ('DriveAway booking deep-link'), and distinguishes from sibling search tools by noting 'no search needed'.

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 usage context: use this once dates are chosen to provide a 'book now' link, and it explicitly says 'no search needed' to prevent misuse. It does not name a specific alternative tool, but the sibling list contains relevant search tools, making the guidance practical.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds valuable context by enumerating the returned data (features, address, photos, rating, etc.), which is not present in the schema or annotations. This clarifies what the agent can expect from the response.

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. It begins with the action and resource, then lists the key return fields without superfluous wording. Every part adds value, making it appropriately concise.

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

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

For a simple, one-parameter read-only getter with no output schema, the description provides sufficient context by naming the main response content. It does not discuss error cases or edge scenarios, but the low complexity and safe annotations make this acceptable. A small gap is that 'accommodation' is included but not elaborated, though not a blocker.

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 fully describes the only parameter (entity_id) with a clear description: 'The unique entity ID of the campsite'. The description's mention of 'by its ID' adds no new semantics. Since schema coverage is 100%, 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 clearly states the verb 'Get' and the resource 'full details for a specific campsite or accommodation by its ID', distinguishing it from search-oriented siblings like search_campsites and list-type tools like get_features. The scope (by ID) is explicit and unambiguous.

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

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

The description clearly conveys when to use the tool: when you have an entity ID and need complete details for a specific campsite or accommodation. It does not explicitly name alternatives or exclusion criteria, but the context is strong enough that an agent can infer this is the detail-by-ID endpoint.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds that it returns a 'full list' and is for filter clarification, but it does not elaborate on return structure, ordering, or edge cases. This is adequate given the annotation coverage, but no extra behavioral depth is provided.

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 action and resource, and the second sentence gives a practical use case. No redundant or filler content.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description is adequately complete. It covers purpose, usage context, and relies on annotations for safety. Minor missing details like exact return format are not critical at this complexity level.

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

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

The single optional parameter feature_type has a clear schema description ('Filter by feature category'), providing 100% coverage. The tool description does not add meaning beyond the schema; it merely implies the filter behavior when mentioning 'full list'.

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 full list') and resource ('available features/amenities that campsites can have'). It distinguishes this tool from sibling tools like get_accommodation_types and get_regions by focusing specifically on campsite feature filters.

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: 'Use this to help users understand what filters are available or to clarify what a feature means.' It provides clear context but does not name alternative tools or explicitly state when not to use it, so a minor gap remains.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds return format ('Returns region names with entity counts') and the optional state filter, which goes beyond the annotations but not extensively. No contradictions.

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

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

Two sentences, front-loaded with action, and every clause earns its place. No fluff 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 list tool with one optional parameter and no output schema, the description covers purpose, usage context, and return content, making it fully self-contained. No additional details are 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?

Schema coverage is 100%, with the state parameter already having a description and enum. The description merely reiterates 'optionally filtered by state' without adding new semantic detail, so it meets the baseline but adds no extra value.

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 ('List') and clearly identifies the resource ('camping/accommodation regions'), while also stating optional filtering and return content. This distinguishes it from sibling tools like search_campsites or get_campsite_details.

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

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

Provides clear when-to-use context: 'Use this when the user wants to browse by area or doesn't have a specific location.' This gives a strong usage signal, though it does not explicitly mention exclusions or alternatives, missing the full 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?

Annotations already declare readOnly, idempotent, non-destructive. The description adds valuable behavioral context: automatic GPS lookup for campsite_name via Neo4j, and the return fields (max/min temp, rain chance, etc.). Does not contradict annotations, and adds beyond the structured metadata.

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

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

The description is well-structured: purpose first, then input options, then return data. Every sentence adds value, no redundancy, and it is appropriately sized for the tool's complexity.

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 3 optional parameters and no output schema, the description fully covers what the tool does, when to use it, how to invoke it, and what it returns. It is complete for an agent to select and use 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 covers 100% with descriptions for each parameter. The description adds relational semantics: 'You can provide EITHER campsite_name OR latitude+longitude', clarifying the mutual exclusivity and how each mode works. This goes beyond the schema's individual parameter 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 states a specific verb and resource: 'Get a 14-day weather forecast for a campsite or location.' It clearly describes the tool's function and the types of data returned. No sibling tool provides weather, so differentiation is implicit but the scope is well-defined.

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

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

Explicitly states when to use: 'Use this when the user asks about weather, temperature, rain, wind, or UV conditions at a campsite or destination.' It also provides guidance on the two input modes (campsite_name vs latitude/longitude), making it clear how to choose between them.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by explaining how recommendations are derived from campsite features (e.g., fishing → fishing gear, 4WD → recovery equipment), which goes beyond the annotations.

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

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

The description is three sentences, each earning its place: purpose, examples, and usage guidance. It's front-loaded with the primary action and avoids any filler or repetition.

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 2 parameters and full schema coverage, the description is complete. It explains the tool's purpose, provides illustrative examples, and gives clear usage guidance. No output schema is present, so return values are not required to be 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 already covers both parameters with complete descriptions (entity_id is 'The campsite entity ID to recommend gear for'; limit is 'Max products to return'). The description doesn't add parameter-specific details beyond what the schema provides, so 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: 'Recommend relevant products and gear for a specific campsite based on its features and type.' It uses a specific verb ('recommend') and resource ('camping gear'), and provides concrete examples that distinguish it from sibling tools like search_products.

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: 'Use this when a user asks what to bring or buy for a particular campsite.' It does not explicitly name alternatives or when-not-to-use, but the context is clear that it's for campsite-specific recommendations, not general product searches.

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 discloses meaningful behavioral traits beyond annotations: it is a live search via DriveAway, returns specific fields (brand, name, sleeps/seats, 4WD, AUD pricing), and includes a booking_url deep-link. It also explains that each result is already complete, preventing redundant follow-up calls. This substantially supplements the readOnly/idempotent 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?

Three sentences that front-load the core action, follow with usage context, and finish with return-value details. Every sentence earns its place; there is 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?

Given there is no output schema, the description fully describes the return contents and the booking link, which is essential for an agent to know what to expect. It also covers the geographic scope, the live nature, and the distinction from sibling tools, making the description complete for practical 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 descriptions already cover all 5 parameters with examples and ranges, so the baseline is 3. The description adds contextual semantics: 'Australia only' clarifies pickup_city validity, 'AUD price' implies currency expectations, and 'nightly and total' clarifies what the price amounts represent, going slightly beyond the raw schema.

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

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

The description opens with a specific verb+resource: 'Search live campervan / motorhome hire availability and pricing' for a pickup city and travel dates. It explicitly distinguishes itself from sibling tool search_campsites, stating it is for RENTING rather than camping.

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 guidance: 'Use this when the user wants to RENT a campervan, motorhome or RV' and contrasts directly with search_campsites. It also notes 'Australia only' as a hard constraint and clarifies that no separate resolve step is needed, helping the agent decide when to invoke this tool.

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

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

Beyond the annotations (readOnly, idempotent, not destructive), the description discloses critical behavioral traits: 'results never mix countries', 'Only campsites that have ALL requested features will be returned', and the pet policy with 'NEVER recommend a campsite with No Pets'. This adds substantial context not present in annotations or schema.

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

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

The description is quite long but well-structured with clear section headers (COVERAGE, IMPORTANT, CRITICAL). It front-loads the purpose in the first sentence. The length is justified by the need to explain feature names and pet policy, but it still could be trimmed without losing essential info.

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

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

Given 10 parameters, no output schema, and no required params, the description is remarkably complete. It explains country coverage, feature filtering behavior, pet policy, entity types, and provides coordinate examples for near_latitude/longitude. No critical gaps remain for an agent to misunderstand tool usage.

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

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

The schema already provides 100% parameter descriptions, so the baseline is 3. The description adds extra semantic depth through the AVAILABLE FEATURE NAMES list, the pet-policy mapping, and entity_type examples (free camping, caravan parks, etc.), which go beyond the schema's per-parameter descriptions.

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

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

The description clearly states 'Search for campsites, caravan parks, or accommodation by location, features, and other criteria' — a specific verb+resource. It also distinguishes itself from sibling tools with the directive 'Use this when the user asks to find a place to stay, camp, or explore.'

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 'Use this when...' sentence provides clear contextual guidance, and the coverage section explains when to set the country parameter. However, it does not explicitly mention alternatives or exclusions (e.g., 'use search_campervans for campervans'), so it lacks fully explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to restate safety. It adds 'available in the Camping Australia store' (scope limitation) and the 'what to buy/bring' use case, which are useful behavioral cues. However, it doesn't add further details like response format or filtering behavior.

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

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

Two sentences, front-loaded with the action and resource. The second sentence is a direct usage trigger. No wasted words or repetition of schema 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?

For a read-only search tool with three well-documented optional parameters and no output schema required, the description is sufficient. It tells the agent what the tool searches and when to use it. The annotations cover safety, and the schema covers parameters, so no critical information 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?

Input schema covers 100% of parameters with descriptive text for each (limit, query, product_type). The description's list of product types ('gear, outdoor products, accessories') loosely maps to query/product_type but adds no syntax or format details beyond what the schema already provides. Baseline 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 uses a specific verb ('Search') and resource ('camping gear, outdoor products, and accessories available in the Camping Australia store'). It clearly distinguishes itself from sibling tools like search_campervans and search_campsites by focusing on store products and gear.

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

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

Provides explicit when-to-use guidance: 'Use this when a user asks about gear, equipment, products, or what to buy/bring.' It does not mention when not to use it or name alternative tools, so it misses the top bar but still gives clear context.

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