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

Annotations already declare read-only, idempotent, closed-world, and non-destructive behavior. The description adds valuable mode-dependent return behavior: listing all questions with slug and result count, or returning places for a given slug. It does not detail pagination, but the schema covers that.

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 appropriately sized and front-loads the core purpose with examples. The second paragraph efficiently explains the two modes. It is slightly verbose with examples but every 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?

Given the output schema exists and annotations cover safety, the description is complete enough for an agent to call the tool correctly. It explains both modes, including how to obtain slugs from the list mode, which is essential for chaining.

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 defines each parameter. The description adds meaning beyond the schema by explaining that omitting slug lists all questions with their slugs and counts, while providing a slug returns that question's places. This clarifies the optional slug's behavior.

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

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

The description clearly states it provides ready-made lists answering common dog-access questions and gives concrete examples. It distinguishes the tool's nature as curated Q&A lists rather than free-text search, though it does not name a specific sibling alternative.

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

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

It explains the two usage modes: without a slug to list all questions, and with a slug to fetch places for a specific question. It gives clear context for when each mode applies, though it does not explicitly exclude or compare against sibling tools like search_places.

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

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

The annotations already declare this as a read-only, idempotent, non-destructive operation, so the safety profile is covered. The description adds useful behavioral context beyond annotations by naming the event outcomes, saying results are newest first, and explaining the radius/place scope, though it does not add much about pagination or response behavior.

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

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

The description is front-loaded with the core operation and scope, then gives usage context, the sibling alternative, and a compact example. Every sentence adds routing or invocation value without 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?

Given the rich input schema, output schema, and safety annotations, the description is complete enough for an agent to select and invoke the tool correctly. It covers purpose, scope, ordering, event types, usage context, and the key alternative, while relying on structured fields for detailed optional parameters and 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 100%, so the schema already documents all eight parameters, including enums and nested point fields. The description adds a useful example mapping place and since, and reinforces the town/county/point radius concept, but it does not explain optional filters like outcome, limit, offset, or response_format beyond what the schema supplies.

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 resource and verb-like operation: verification events since a date within a radius of a town, county, or point, returned newest first. It explicitly distinguishes this from dogpolicies_changes_since, which covers everything everywhere, so an agent can route correctly without opening the schemas.

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

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

It gives concrete usage conditions: answer questions like whether anything changed around Tahoe since a last trip, or re-check a saved itinerary. It also names the alternative tool dogpolicies_changes_since and states when to use that instead, which removes 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?

The annotations already declare this is a read-only, idempotent, non-destructive operation. The description adds useful behavior beyond that: results are newest first, entries include place, outcome, who checked, and record links, and the outcome set is enumerated. It does not cover auth or rate limits, but it provides solid 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 a single, front-loaded sentence that quickly states the purpose before adding detail. It is dense but every clause is relevant, though the outcome enumeration duplicates schema information slightly.

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 annotations covering safety and an output schema present, the description provides enough context to call the tool correctly: what changes are included, ordering, entry contents, and the polling use case. It need not explain return values further because the 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%, so the schema already documents parameters like since, limit, offset, outcome, and response_format. The description reinforces the date scope and outcome categories but does not add syntax or format 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?

The description states a specific verb and scope: changes in the whole data set since a date, covering verification events and rule changes. The phrase 'whole data set' and 'everywhere' implicitly distinguishes it from the location-scoped sibling dogpolicies_changes_near, so an agent can tell which change-feed tool to use.

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

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

It gives a clear usage context: an agent can poll this cheaply instead of re-reading every record. It does not explicitly name alternatives or exclusions, but the contrast with 'whole data set' versus a near-scoped feed is clear enough for an agent to infer when to use this tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context: the output layout (one row per fact, one column per place, citations for every place) and the inclusion of confidence, freshness and confirmer provenance — information not visible from 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?

Front-loaded with the user's question and the comparison scope, then usage and example in a compact second paragraph. Slightly redundant in repeating the 2–6 range already enforced by the schema, but otherwise every sentence carries 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?

With an output schema present and annotations covering safety, the description correctly focuses on comparison semantics and provenance rather than return-value mechanics. What an agent needs to select and invoke it is essentially all present; only explicit sibling exclusions are missing.

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

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

Schema coverage is 100%, so baseline is 3. The description goes beyond it by restating the 2–6 cardinality constraint in prose and supplying a concrete ids example (["carmel-beach","asilomar-state-beach"]), which clarifies id format in a way the schema's plain string type does not.

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

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

Opens with a specific question-form verb framing ('Compare two to six places') and enumerates exactly which attributes are compared (dogs allowed, leash rule, pet fee, weight limit, etc.). This clearly distinguishes it from dogpolicies_get_place (single place) and dogpolicies_search_places (candidate discovery).

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 the trigger condition: 'Use after a search returned candidates and the user asks "which one?"' and notes that ids come from any search result, with a concrete example. No explicit when-not clause (e.g., 'do not use for a single place, use get_place'), so it falls 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's added value is in result behavior: the match/possible/excluded taxonomy, the rule that matches come first ordered by cheapest pet fee, and that fee arithmetic is shown per result. That is meaningful context an agent cannot get from annotations. It does not address pagination behavior or what an empty result set looks like.

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 purpose sentence, then a compact taxonomy paragraph, then four tight examples — the ordering is sensible and nothing is filler. It runs slightly long overall, but each example demonstrates a genuinely different invocation pattern.

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 15-parameter tool with a nested object, enums and an output schema, the description covers purpose, result classification, ordering and query-shaping examples well. It never states how the competing geography filters (state, region, area, county, near, query) interact or take precedence, which is the one thing an agent could get wrong on a tool this wide.

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 would be 3; the description earns above that by showing concrete parameter pairings that the schema never illustrates (near={lat,lon} for 'near Palm Springs', county+state for disambiguating, query for a named property). One minor inconsistency: the schema says 'near' results are sorted by distance while the description says matches sort by cheapest pet fee, leaving the precedence 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?

Opens with a specific verb-and-resource plus scope: find hotels/motels in California and Nevada that accept a specific dog, including estimated pet fee. That is far more precise than the title alone. It stops short of naming any sibling (e.g. dogpolicies_search_places or dogpolicies_near) to explain how this differs from a generic place 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 four worked examples effectively show how real user questions map onto parameter combinations (county+weight+fee cap, near+count, query, state+weight), which is strong practical guidance for invocation. What is missing is explicit routing: nothing says when to choose this over dogpolicies_near or dogpolicies_search_places, nor any exclusion 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine context the annotations don't: what content the policy contains (limits, fees, exceptions) and the added dimension of California/Nevada property counts. It omits what happens for an unrecognized brand, which keeps it 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?

Two compact blocks: the return payload first, then the accepted inputs. Every element earns its place, and the enumerated brand list directly reduces lookup failures rather than padding the text.

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

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

With an output schema present, the description needn't explain return structure, and it still summarizes payload contents well. The only real gap is behavior for a brand outside the six listed chains — an agent can't tell whether that errors or fuzzy-matches.

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, but the description earns more by listing the exact accepted brand values and showing that both slug ('red-roof') and display-name ('Kimpton') forms work — detail the schema's 'Brand id or name' does not resolve on its own.

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 first sentence names the resource precisely (a hotel chain's published pet policy) and enumerates the fields returned: pets per room, weight limit, fee, rules, exceptions, and CA/NV property counts. The brand-level scope is clear enough to separate it from property-level siblings like dogpolicies_get_place, though no sibling is named explicitly.

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

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

Usage is implied by the brand-level framing and the enumerated brand list, so an agent can infer 'use this for chain-wide policy'. However, there is no explicit when-to-use/when-not statement and no routing to alternatives such as dogpolicies_get_place for a specific property or dogpolicies_get_rule for a regulation.

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 useful content-shape context (rules carry display text; sources carry URL, publisher, capture date, quote), which tells the agent this is the heavy-detail endpoint versus a search hit; it does not mention response size or cost of a full fetch.

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 front-loaded first sentence is good, but the second sentence re-says the same thing ('Full rules and sources for one place: every fact with its display text, the rules list, and each source with its URL, publisher, capture date and quote'), a near-duplicate that consumes space without new information. The usage hint and example are buried after the 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 an output schema present, the description need not explain return values, and annotations cover the safety profile, so the remaining burden is provenance and precondition — both addressed via the sibling-tool routing. A note on behavior for unknown or ambiguous ids is the only meaningful 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?

Schema description coverage is 100% and both parameters are documented, including the response_format enum, so the baseline is 3. The only added value is an example id ("carmel-beach"), which duplicates the schema's own example ("fort-funston") and adds nothing about id format or fallback behavior when an id is unknown.

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 ('The full record for one place') and enumerates what that record contains: dog rules, rules list, and sources with URL, publisher, capture date and quote. It also distinguishes itself from siblings by noting the id comes from dogpolicies_search_places or dogpolicies_find_hotels, though the second sentence restates the first almost verbatim rather than adding scope.

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?

'Use after dogpolicies_search_places or dogpolicies_find_hotels, which return ids' gives a clear precondition and names the producing tools. It stops short of exclusions — nothing says when to prefer dogpolicies_get_rule, dogpolicies_compare_places, or a search snippet instead of pulling the full record.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds useful content about what the record carries (source, quote, confidence, verified date, freshness, citation line), but says nothing about behavior on a missing/unknown id or any lookup limits. With annotations carrying the safety burden, 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?

Purpose is front-loaded in the first clause, and the id-format note is a legitimate second sentence rather than filler. The middle list of returned fields is somewhat dense and partly duplicates the output schema, but each element is informative.

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-by-id tool with a full output schema and complete parameter coverage, the description supplies everything an agent needs: what it returns, what the id looks like, and where ids come from. The only gap is behavior on an unknown id, which is a minor omission given the output schema handles the return shape.

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 both parameters are already documented, and the schema itself supplies a concrete id example. The description adds marginal value by explaining the id pattern 'rul_<place uid>_<kind>' and its origin in place results, but gives no guidance on response_format beyond what the enum already conveys.

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 (fetch one rule by stable id) and immediately disambiguates what a 'rule' is with concrete examples (fee, leash rule, weight limit). This clearly separates it from sibling tools like dogpolicies_get_place, which returns a whole place rather than a single rule.

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

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

Usage is implied rather than stated: the note that rule ids 'appear in every place result as rule_records' tells the agent where to get an id, which implies the get_place -> get_rule workflow. However, it never explicitly says when to use this instead of get_place or get_brand_policy, and gives no exclusions or error 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?

Annotations already declare read-only, idempotent, non-destructive and closed-world, so the safety profile is free; the description adds real value by describing the result shape (grouped by kind, distance-sorted, dog rule plus citation per entry). The notable omission is the geographic limit — the tool only covers California and Nevada (lat/lon bounds and the place field say so), yet a user asking about Portland would get a confusing result and the description never warns of this.

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 the identity sentence, then usage routing, then compact examples — each block does distinct work. The examples are the highest-value part for an agent composing arguments and are formatted for scanning rather than 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?

An output schema exists, so return values need no prose, and all seven parameters are documented in the schema. The remaining gap is scope: neither the description nor the annotations disclose the CA/NV-only coverage, which is the most likely cause of a wrongly-invoked call given the open-ended "anything nearby" framing.

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 baseline is 3; the description earns an extra point by demonstrating argument composition through worked examples (place alone, place plus types, near plus radius_miles). It does not clarify the interaction between dogs_allowed_only and the rest-area/stop kinds, or what per_type does to a radius-wide search beyond the schema text.

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?

"Anything for dogs around a town, county or point" gives a specific resource and scope, immediately followed by what is returned (beaches, parks, trails, lodging, food, rest areas grouped by kind and sorted by distance). The one-liner "the one call to make when a user names a place and asks 'what can I do with my dog there?'" pins down its role against the many 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?

Explicitly routes to alternatives with the selecting condition: find_hotels for weight/budget questions, plan_trip for a whole stay, search_places for a single kind with filters. It also pre-empts the common input ambiguity by stating no coordinates are needed for a town, and the three examples map realistic user phrasings to arguments.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds value beyond that: it says the pet fee is computed for the whole stay, that activities come 'nearest first', and that every item carries a citation. It does not explain what 'Include stays that need a call to confirm' means operationally, which keeps it out of the top score.

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

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

The first sentence is front-loaded with the outcome and its three sections, followed by a short input paragraph and compact examples. The examples take meaningful space but each illustrates a distinct parameter mapping (fee cap, multi-dog, county + stay_types), so they earn their place. Minor redundancy between the input sentence and the examples' parameter lists.

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

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

With 11 parameters, a nested `near` object, an output schema, and full annotations, the description covers the primary decision inputs and outcome shape well. It omits the point-coordinate alternative (`near`), radius_miles, per_section and response_format, but the schema documents those fully and the output schema removes the need to explain 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 100%, so 3 is the baseline. The description goes further by grouping the required inputs semantically ('the town or county and the dog: weight, how many dogs, nights, and the most the user will pay in pet fees') and by showing in the examples that max_total_fee is per stay and that county names unlock camping results. It leaves radius_miles, per_section, response_format and the `near` object to 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 uses a specific verb and resource ('Plan a stay ... with a dog, in one call') and enumerates exactly the three sections it returns: lodging, activities and dog-friendly patios. It also scopes the region (California or Nevada) and distinguishes itself by naming the siblings it is not (dogpolicies_route_stops, dogpolicies_near), so an agent can tell the tools apart 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?

The description gives explicit routing: 'Use dogpolicies_route_stops for the drive there and dogpolicies_near for a quick list without the stay check', which names the alternatives and the condition that selects them. Three worked examples map realistic user phrasings ('camping near Mammoth Lakes' -> stay_types, 'two small dogs' -> dogs=2) to invocations, so the agent knows both when to use it and how to translate requests.

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, it discloses that the report goes to a person who re-reads the official source, that nothing is published automatically, and that the record does not change until verified. It also includes a privacy constraint, and none of this contradicts the mutation/non-destructive 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 front-loaded with the trigger and behavior, then parameter guidance, then privacy. Four sentences, each carrying useful information with 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?

An output schema exists, so return values need not be explained, and the annotations cover safety hints. The description supplies the trigger, human-review behavior, parameter guidance, and privacy constraint needed to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful usage guidance for all four parameters: place id, a sentence or two for the message, the official page if available, and an optional contact. It mostly reinforces the schema rather than adding deep parameter-specific semantics.

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, 'File a correction,' and defines the triggering scenario with concrete examples such as a fee change or beach closure. No sibling tool appears to be a correction-reporting tool, so the purpose 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 clear when-to-use condition: when a user says a rule on a record is wrong or has changed. It does not explicitly name when not to use it or list alternatives among the sibling lookup/search tools, but the context is strong enough for an agent.

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/closed-world, so safety is covered. The description adds genuine behavioral context beyond that: results are weight- and pet-fee-filtered, each stop carries mile and off-road distance, routes stop at state lines, and US-101/Highway-1 overlaps are flagged via on_road.

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 purpose is front-loaded in the first sentence, which is strong. However, the second and third paragraphs are dense walls of route-mile arcana (odometer origins, shared-highway stretches, per-route mileage) that largely restate the route enum and slow an agent down before it reaches the usable examples.

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 an output schema, the description supplies the one thing the schema doesn't enforce — that a starting point and direction are needed — and explains mileage conventions. Return values need no explanation given the output schema; pagination and multi-dog semantics are left to the schema.

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

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

Schema coverage is 100%, so baseline is 3, but the description meaningfully enriches several parameters: direction is explained as increasing-miles north/east, route ids are tied to specific highways and lengths, max_total_fee is scoped to the whole stay, and dog_weight_lb drives lodging eligibility. It doesn't address offset/limit pagination or the dogs count.

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 — dog-friendly stops along a California or Nevada highway — and adds the ordering guarantee (driving order), the kinds of stops, and the filtering rules (dog weight, pet-fee budget). It also implicitly distinguishes itself from siblings like search_places or find_hotels by being route/mile-based rather than place-query-based.

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 five worked examples that map natural-language questions to invocations, plus the explicit rule 'Give a starting point with from_mile or near, and a direction.' It does not name the sibling alternatives (e.g. dogpolicies_near, dogpolicies_find_hotels) or state when to prefer them, so routing between tools 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 readOnly/idempotent/non-destructive, so the bar is lower, but the description still adds real context: one page of results, the status vocabulary (yes, yes_restricted, no, varies), the one-line answer format, verification dates, and that near-results are distance-sorted. It does not spell out rate limits or how offset/limit interact across pages.

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?

Purpose, return shape, and sibling routing come first, which is the right order. The eight examples are individually useful but collectively heavy; a few overlap in shape (multiple type+county+dogs_allowed variants), so some trimming would preserve the value.

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

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

For a 12-parameter, fully documented, output-schema-backed search tool, nothing an agent needs to call it correctly is missing: scope, filters, return shape, pagination parameter, and handoffs to the right siblings are all 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?

Schema coverage is 100%, so the baseline is 3; the description earns above that by mapping natural-language requests onto concrete parameter combinations (type+off_leash+near, type+county+dogs_allowed, type+state+dogs_allowed), which is information the schema alone doesn't convey. It doesn't add format hints beyond what the schema enumerations already provide.

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

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

States a specific verb and resource (search places), the covered categories, geography (California and Nevada), and the filterable axes (name, location, dog rules). It also explicitly distinguishes itself from dogpolicies_get_place and dogpolicies_find_hotels, so an agent can route without opening another 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?

Names two sibling tools and the exact condition that selects each: get_place for full rules and sources, find_hotels for a specific dog's weight and budget. The worked examples further show when a name query versus structured filters is the right shape.

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