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

With no annotations present, the description carries the full disclosure burden and does well: it explains the rate-selection rule (government-furnished automobile switches standard to reduced rate), the fallback to today's date, and exactly what the response contains including rounding to the nearest cent. It stops short of explicitly stating this is a pure computation with no side effects.

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

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

Front-loaded with the core purpose, then conditional rules, then defaults and return shape — a logical order with little waste. The first line largely duplicates the title, a minor redundancy for an otherwise tight paragraph.

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 specifies the returned fields (rate category, rate, effective date, rounded amount), and it covers default behavior and conditional rate logic. An agent has everything needed to call it correctly and interpret the result.

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 adds genuine meaning by explaining the semantic consequence of government_vehicle_available (determines standard vs reduced rate) and that the date drives effective-rate selection. It does not restate the numeric bounds, which the schema already covers.

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 ('Calculate POV mileage reimbursement', 'using the official GSA rate in effect on the travel date') and enumerates the supported categories. It is clearly distinguishable from sibling rate-lookup tools like get_mileage or get_fleet_rates_by_sin, which retrieve data rather than compute an amount.

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 what inputs are needed and the conditional logic for automobile travel, so usage is implied clearly, but it never names an alternative tool or states when not to use this one (e.g., when to look up rates via get_mileage instead of computing).

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

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

With no annotations, the description carries the full behavioral load and does so: 75%/100% M&IE split, daily rate selection across seasonal and fiscal-year changes, lodging capped at the GSA nightly limit with excess reported as 'overage' and excluded from the payable total, and null totals when lodging cost is omitted. It also discloses that responses carry a calculation version and source fingerprint for auditing.

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 a one-line purpose, then organized into trip description, calculation rules, and notes — an agent can skim the headings. There is some duplication with the schema (ZIP/destination ID guidance, boundary-date rule), but nearly every bullet carries operational 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?

No output schema exists, so the description must describe return values, and it does: daily breakdown, trip totals, overage, null-total condition, and audit metadata. For a 3-parameter calculator this leaves nothing an agent needs before calling it.

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, but the description adds interpretive weight: it explains that a stop's location is the TDY locality rather than the hotel, clarifies who owns a shared boundary date, and states the downstream consequence of omitting lodging_cost_per_night. Only verification_url goes unmentioned.

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 line states a specific verb and resource — 'Calculate a GSA CONUS trip per diem entitlement' — and the following paragraph scopes it to multi-stop CONUS trips that return a daily breakdown plus trip totals. That verb-plus-trip-scope framing distinguishes it from the many rate-lookup siblings (get_gsa_perdiem_by_zipcode, get_mie_breakdowns) without needing to name them.

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?

Extensive rules on how to structure input: stops in travel order, inclusive dates, TDY locality vs hotel location, transition-date ownership, and the FTR 301-11.21 precondition for meal deductions. It never explicitly says when to prefer this over rate-lookup siblings, but the trip-level intent is clear context.

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

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

No annotations exist, so the description carries the full load. It does disclose the return shape (rate percentage plus annual and biweekly amounts), which is genuinely useful, but says nothing about the effect of omitting the optional date, what happens with an invalid/non-DSSR postcode, or any auth/rate constraints. Read-only calculation is the obvious behavior, so the risk is low.

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 short sentences, front-loaded with the resource and followed by return values. Minor redundancy between 'COLA calculator' and 'COLA calculations', but nothing wasteful.

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 four-parameter tool with no annotations and no output schema, describing the three return values is a real contribution. However, the semantics of the optional date (default, as-of behavior) and postcode validity handling are left entirely to the caller's assumptions.

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 postcode, family_size, base_salary and date, including format and units. The description adds no parameter-level meaning beyond that, so the baseline 3 applies; notably it never mentions the optional date parameter or its default.

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

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

States a specific verb and resource (COLA calculation for a DSSR postcode) and names the concrete outputs (percentage rate, annual and biweekly amounts), which clearly separates it from the mileage and per-diem calculators in the sibling list. It doesn't explicitly name an alternative, but the resource is distinct enough to route on.

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 line about automating COLA calculations and replacing the official excel file implies the intended usage context, but there is no when-to-use vs when-not guidance and no mention of the other calculation tools (mileage, per diem) or of prerequisites such as having a valid DSSR postcode.

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

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

No annotations are provided, so the description carries the full disclosure burden and discloses almost nothing. It does not say the tool is read-only, whether results are a single record or a list, whether a missing country yields an empty result or an error, or what verification_url actually does to the payload — even though the schema shows it changes 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?

At five words there is zero waste, but this is under-specification rather than true conciseness — the single fragment ends before conveying anything actionable. Nothing is front-loaded because there is essentially no content to order.

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 four-parameter tool with no annotations and no output schema, the description should at minimum establish what is returned and how it differs from the location/postcode variants. Instead it leaves the agent to reconstruct all behavioral context from 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 description coverage is 100% and the parameter docs are unusually rich (ISO code examples, ZZ caveat, alias handling for type, date format), so the schema already does the semantic work. The description adds nothing beyond it, which is the baseline-3 case rather than a failure.

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 fragment 'DSSR allowances by country' names the resource (DSSR allowances) and its scope (by country), which does distinguish it from siblings like get_allowances_by_location and get_allowances_by_postcode. However, it is a noun phrase with no verb and never says what a DSSR allowance is or what 'get' returns, so an agent must infer the operation from the tool name alone.

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

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

There is no when-to-use guidance, no excluded cases, and no routing instruction. The sibling set contains at least three other allowance lookups (by_location, by_postcode, and per-diem variants), yet the description gives no rule for choosing among them beyond the implicit 'by country'.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only states the resource and does not disclose required permissions, read-only status, return shape, pagination, or error 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 a single front-loaded phrase with no waste, but its brevity reflects under-specification rather than efficient structure for a five-parameter tool.

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

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

With no annotations and no output schema, the description should compensate by covering required country code, filtering behavior, and verification_url. It does not, leaving essential context to the schema alone.

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 date, type, location, country_iso_code, and verification_url in detail. The description's 'location name' adds no meaning beyond the schema's location field; 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 phrase identifies the resource (DSSR allowances) and the lookup dimension (location name), which is enough to infer retrieval. However, it omits an explicit verb and never names sibling alternatives such as get_allowances or get_allowances_by_postcode, so it falls short of full differentiation.

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

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

There is no when-to-use guidance or comparison to alternatives. The agent is not told when to choose this tool over get_allowances, get_allowances_by_postcode, or other DSSR location tools.

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

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

With no annotations at all, the description carries the full disclosure burden and delivers almost nothing: 'get' implies read-only, but there is no mention of return format, whether results are date-sensitive, pagination, or the ZZ 'Other Foreign Localities' special case. The useful behavioral context exists only in the schema, not the description.

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?

Seven words with zero waste, but it is under-specified rather than efficient for a tool with five parameters and many close siblings. There is no front-loaded verb or scope statement to anchor the agent.

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

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

A parameterized lookup with no annotations, no output schema, and a crowded family of similar tools demands more than a fragment. Nothing explains the relationship to get_allowances_by_location or the date/type filtering behavior an agent would need before calling it.

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 five parameters — including the allowance-type enum, date, and verification_url — are already well documented in the schema. The description adds nothing beyond restating that postcode is the key, which caps this at the baseline 3.

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 phrase names the resource (DSSR allowances) and the lookup key (location post code), so an agent grasps the basic operation. But there is no verb and no differentiation from near-identical siblings such as get_allowances_by_location, get_allowances, and get_perdiem_allowance_by_postcode — an agent cannot tell why it should pick this one over the location-based variant.

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

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

No guidance on when to use this versus the postcode-based or location-based alternatives, no prerequisites, and no exclusions. The 'by post code' phrasing weakly implies a usage context, but nothing states it.

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

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

With no annotations, the description carries the burden and does well: it discloses ordering, the fact that all codes are returned unpaginated when `q` is omitted, that multiple codes can share a city label, that labels track the latest imported awards table and change with it, and that behavior varies by plan tier (Sandbox/Google add-on today only, Pro current fiscal year, Business any loaded year). It stops short of stating rate limits or error behavior, so not 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?

Front-loaded with the purpose and the critical 'resolve here first' instruction, then falls back to mode and plan details. Slightly dense: the curl example and the deferral of plan rules to the fare lookup ('Plan/date rules are those of the fare lookup') add modest weight, though both are defensible for a public API.

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 2-parameter, no-annotation, no-output-schema read tool, the description covers what is returned (codes plus GSA city/state/country labels), ordering, filtering semantics, and access-tier constraints. An agent could invoke this correctly without opening 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 adds real meaning: `q` semantics (exact code match vs. case-insensitive substring on city/country names, 3-character minimum, omission returns everything) and that `date` selects the fiscal year, not a fare date. This goes beyond the schema's terse property descriptions.

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

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

States a specific verb and resource: list/search the three-letter GSA City Pair codes for a fiscal year, with GSA's own city/state/country labels. It explicitly distinguishes itself from the fare-lookup sibling by telling the agent to resolve codes here before calling the fare lookup, and clarifies the airport-code vs. metro-code ambiguity that would otherwise be a trap.

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 routing ('resolve the code here before calling the fare lookup'), spells out both modes (without `q` = full listing ordered by code; with `q` 3+ chars = exact code match or substring name match), and enumerates which plan tiers can query which fiscal years. Alternatives and exclusions are both present.

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

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

With no annotations, the description carries the full burden and does so thoroughly: output ordering, one-way USD fares valid in either direction, inclusive source dates, overlapping amendments both returned, null fare categories unavailable, no cross-fiscal-year fallback, tier-based date limits, and data freshness ('latest imported table, not past publication snapshots'). It also discloses that these are eligible contract prices, not live availability, and that caching means newly imported data needs X-Bypass-Cache: 1.

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 core action is stated in the first content sentence and nearly every subsequent sentence adds a genuine caveat (fees, tiers, caching, freshness). It is dense and slightly over-long — the external links and full curl example could be trimmed — and the opening bare fragment 'City Pair contract airfares' delays the actual verb.

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 lookup with no annotations and no output schema, the description covers behavior, data provenance, pricing caveats, and access-tier limits well, but defers result field details to an external '200 response example' and does not say what an empty match set looks like.

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

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

Schema coverage is 100%, so origin/destination/date/verification_url are already documented, and the description largely restates the code-pair semantics. It adds only the 'today by default' date behavior and tier-dependent date ranges beyond the schema, which is a marginal increment over the baseline for fully described 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?

States a specific verb and resource: returns GSA City Pair contract award airfares for an airport/city code pair and date. It is clearly distinguishable from siblings like get_city_pair_locations (location lookup) or get_gsa_perdiem_by_destination (per diem rates).

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

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

Gives explicit access-tier conditions (Sandbox/Google add-on = today only; Pro = current fiscal year; Business = any loaded fiscal year), states there is no fallback to other dates/fiscal years, and says to book through the agency's authorized system. It stops short of routing the agent to a specific sibling (e.g., get_city_pair_locations) when the code itself is unknown.

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

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

No annotations are provided, so the description carries the full behavioral burden. It indicates that the tool resolves a country and returns posts, but it does not say whether the operation is read-only, how pagination behaves, what happens when q is omitted, or what the response includes.

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

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

The description is a single front-loaded sentence with no filler. However, its brevity leaves important gaps rather than being fully optimized for correct invocation.

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, no output schema, and only 33% parameter description coverage, the description is not complete enough. It omits optional-q behavior, pagination semantics, and any indication of return structure.

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

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

Schema description coverage is only 33%: q is documented as a country-name search, while limit and offset are undocumented in both schema and description. The description mentions country name but adds no meaning for pagination parameters and barely goes beyond the existing q 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?

The description states a specific action and resource: resolving a country name to its ISO code and listing its posts. It is clear enough to distinguish a country-resolution tool from calculators and per-diem tools, but it does not explicitly differentiate itself from the sibling get_country tool.

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

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

The description implies usage when a country name needs resolving, but it gives no explicit when-to-use guidance, exclusions, or comparison to alternatives such as get_country. An agent must infer the selection criteria entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not explain what is returned, how invalid ISO codes are handled, or any other behavioral trait beyond the basic lookup.

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

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

A single short phrase with no wasted words, and the essential lookup key is front-loaded. It is slightly too terse for an unannotated tool, but the structure is efficient.

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

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

For a simple one-parameter lookup with full schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it leaves the agent without information about the return value or error behavior.

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

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

Schema coverage is 100%, and the parameter already documents format, examples, the ZZ special case, and how to resolve a country name. The description adds no parameter meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb ('Get') and resource ('country') and the lookup key ('ISO code'). It is clear but does not explicitly distinguish itself from the sibling get_countries, which likely serves a different listing/search purpose.

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

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

The description provides no guidance on when to use this tool versus get_countries or other sibling lookups. The schema note about resolving names via get_countries is helpful but is not part of the description itself.

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

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

With no annotations present, the description carries the burden and does well: it discloses that ID 0 is the Standard CONUS rate area, explains the meaning of the returned `name` vs `defined_name` fields, and scopes the response to metadata only. It omits error behavior for invalid IDs and any auth/rate-limit context, keeping it short of 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?

Front-loaded with the core purpose and organized into purpose, semantics, parameter meaning, and exclusions. Slightly verbose — the long docs URL and the name/defined_name aside add length without being essential to invoking the tool.

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

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

No output schema exists, and the description compensates by describing the key returned fields (name, defined_name) and the geographic concept of a rate area. A brief note on the response envelope or behavior for unknown IDs would make it complete.

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

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

Schema coverage is 100% and already documents `destination_id` including the ID 0 convention, so much is duplication. However the description adds conceptual meaning beyond the schema by spelling out what a rate-area ID can represent geographically, which helps an agent reason about the 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?

States a specific verb and resource ('Get GSA destination metadata by ID') and immediately clarifies the semantic scope of a 'destination' (city, metro area, county, jurisdiction group, or Standard CONUS). This distinguishes it clearly from get_destinations (browse/list) and get_gsa_perdiem_by_destination (rates).

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

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

Explicitly names alternatives and the conditions selecting them: use GET /v1/gsa/destinations to browse and obtain IDs, and use GET /v1/gsa/perdiem/destination/{destination_id} to get per diem rates for a date. It also states a negative constraint — this endpoint returns metadata only, not rates.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses ordering by `destination_id`, pagination behavior, and that an out-of-range offset returns an empty list rather than a 404. It does not mention authentication, rate limits, or pagination metadata, 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?

The description is front-loaded with the core action, then adds only useful context about destination meaning, IDs, fields, and pagination. The sentences are purposeful and there is no obvious repetition or filler.

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

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

For a simple two-parameter list tool with no output schema, the description covers the concept of a destination, the key returned fields, the ID semantics, ordering, pagination, and the empty-list edge case. An agent has enough information to call and interpret this tool correctly.

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

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

Schema description coverage is 100%, so both `limit` and `offset` are already documented in the schema. The description adds useful behavioral context for `offset` (empty list beyond available records), but otherwise does not expand parameter semantics beyond the schema baseline.

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

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

The description states a clear verb and resource: it lists GSA destinations and returns their rate areas and numeric IDs. It also explains what a destination is, which removes ambiguity. It does not explicitly name the sibling tool `get_destination_by_id` as the alternative for looking up a single destination, so it falls short of full sibling differentiation.

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

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

The description gives clear usage context: use a returned `destination_id` with the destination-rate endpoint, and use `offset`/`limit` to page. It explains the special `0` ID for Standard CONUS. It does not explicitly say when to avoid this tool in favor of a specific sibling, so it is strong but not exhaustive.

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

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

With no annotations present, the description carries the full burden and does a reasonable job: it discloses that the response is paginated and that the total count ignores pagination while offset/limit are echoed back. That is real behavioral context beyond the schema. It omits rate limits, auth requirements, and what a 'DSSR location' record actually contains, which keeps it below 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?

Three short, front-loaded sentences with the purpose first, the filter second, and the return shape last. The only waste is the near-duplication of "List DSSR locations" and "Return DSSR locations," which conveys nothing extra.

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

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

The description does cover the return shape, which matters since no output schema exists, and the tool has only three optional parameters. But with an adjacent sibling covering the country-scoped variant and no explanation of what DSSR denotes or how this differs, an agent lacks the context needed to choose 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 only 33% — only q is documented ("Search by name"); limit and offset have no schema descriptions at all. The description partially compensates by naming the q=<name> filter and stating that offset and limit are applied, but it never mentions defaults (10/0) or the maximum of 20 for limit, leaving two parameters under-explained.

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 ("List DSSR locations") that is immediately distinguishable from most siblings such as get_allowances or get_fema_hotels. However, it never distinguishes itself from the near-identical sibling get_dssr_locations_by_country, so an agent cannot tell which of the two to pick from the description alone.

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?

"optionally filtered by q=<name>" implies when the filter is useful, but there is no explicit when-to-use statement, no exclusions, and no mention of the by-country alternative that a sibling list makes obvious. Usage is inferable but not guided.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that this is a bulk read returning 'all' locations for the country (no pagination implied), but it says nothing about response size, ordering, or what happens with codes that have no data.

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 short sentences, front-loaded with the operation and immediately followed by the input requirement. The second sentence largely restates the first ('List... by country' / 'Return all... for a specific country'), so there is minor redundancy but no wasted padding.

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

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

For a single-parameter lookup with no annotations and no output schema, the description is adequate to call the tool correctly. It does not describe what a DSSR location record contains or how large the result set may be, which the agent cannot learn from any structured field.

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

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

Schema coverage is 100% and the single parameter's schema description already covers the ISO 3166-1 alpha-2 format, the ZZ edge case, and the get_countries resolution path. The description only repeats the alpha-2 format with different examples, adding no meaning beyond the schema.

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

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

States a specific verb and resource ('List DSSR locations') plus the scoping dimension ('by country'), so the agent knows this is a country-filtered variant. It never names the sibling get_dssr_locations (presumably the unfiltered version), so the differentiation is only implicit in the phrase 'by country'.

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: use this when you have a country and want its DSSR locations, with the input format spelled out. There is no explicit statement of when NOT to use it versus get_dssr_locations, and the helpful routing hint about resolving names via get_countries lives in the schema, not the description.

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

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

No annotations are provided, so the description carries the full burden. It never states that this is a read-only lookup, what a location record looks like, whether results are paginated, or how many rows a state returns, and it contains a leftover '# todo add filter by location' dev note that muddies rather than informs.

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 core sentence is fine, but the embedded '# todo add filter by location' line is an unedited developer comment that contradicts the state-filtering behavior stated below it and should not appear in a tool definition. Removing it would leave a clean two-line entry.

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

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

For a single-parameter lookup with no output schema, the essentials (state code in, all DTMO CONUS locations for that state out) are present. Still missing is any notion of what fields a location carries or whether the response is bounded, which matters when an agent must decide whether to call this or a per-diem sibling next.

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

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

Schema coverage is 100% and the parameter's own description already explains the US-CA format with examples. The description adds only a redundant restatement of the same format, so the baseline 3 applies rather than anything higher.

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/return DTMO CONUS locations) and scopes it to a single state. The CONUS qualifier, combined with the sibling get_dtmo_oconus_locations, lets an agent infer the domestic-vs-overseas split, though the description never says so 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?

There is no guidance on when to pick this over get_dssr_locations, get_dtmo_perdiem_conus, or get_allowances_by_location, all of which plausibly return overlapping location data. The only implied selection cue is the CONUS token in the name itself.

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

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

With no annotations, the description carries the full burden, and it does disclose the behaviors that matter for this lookup: case-insensitive substring matching, literal handling of spaces and wildcard characters, empty/omitted filter returning everything, and an empty array when nothing matches. It stops short of stating the read-only nature explicitly or describing the returned location record's fields.

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

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

The front-loaded first line states the resource, and the filter semantics follow in a tight block with no wasted clauses. The opening 'Get DTMO OCONUS locations' heading slightly duplicates the title-less name, but overall it is well-sized for a two-parameter lookup.

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 two-parameter list tool with no annotations, the description covers inputs well, but with no output schema it never says what a returned location record looks like (name, code, ID?), which an agent needs to chain into follow-up calls. That is the one remaining 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 coverage is 100% and the schema already documents the ISO 3166-1 alpha-2 code, the 'ZZ' special case, and the get_countries resolution path, so the description only restates the country code. It does add real meaning for `location` beyond the schema's bare 'Filter by location name' — case-insensitive, literal substring with wildcards treated as literal — which lifts it slightly but the redundant country-code sentence caps it at baseline.

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

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

The description uses a specific verb+resource pair ('Return DTMO locations') and scopes it to a single country via ISO code, so an agent can tell what data comes back. It does not, however, distinguish itself from the very close sibling get_dtmo_conus_locations or clarify its relationship to get_dtmo_perdiem_oconus, leaving the CONUS/OCONUS split to be inferred from the name alone.

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 only implied: 'for a specific country' tells you the required scope, and the filter paragraph tells you when to pass `location` versus omit it. There is no explicit statement of when to prefer this over get_dtmo_conus_locations, get_dssr_locations_by_country, or the per-diem lookup siblings, and no prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden; it does disclose the returned rate components and the fiscal-year boundary semantics, which is useful. However it says nothing about pagination behavior despite exposing limit/offset, nothing about the verification_url flag's effect, and nothing about rate limits or auth. Adequate but clearly incomplete for a 7-parameter data tool with zero annotation coverage.

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 scope statement and returned fields are front-loaded before the parameter guidance, and nearly every sentence carries information. The leading 'Get perdiem CONUS' fragment is a near-tautological warm-up that adds little, but the body is dense and well-ordered.

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

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

It covers what the tool returns and how the date/year selectors work, which is the core need given no output schema. It falls short on a 7-parameter, annotation-free tool: three parameters (limit, offset, verification_url) are undocumented anywhere, and the state_iso example contradicts the schema format.

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

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

The description adds real meaning beyond the schema for the date/year interplay and the OCONUS alternative. But it describes the key parameter as a bare state code ('e.g. TX') while the schema mandates the 'US-' prefixed form documented as 'US-CA' — a conflicting example that could cause a malformed call — and it never mentions limit, offset, or verification_url, which have no schema descriptions either.

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 ('Department of Defense per diem for the continental U.S. by state code') and enumerates the values returned (lodging, local/proportional meals, incidentals, max per diem per season). It explicitly scopes itself against the sibling get_dtmo_perdiem_oconus by naming Alaska, Hawaii and territories as out of 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?

Gives concrete selection rules for the temporal parameters ('`date` selects the rates in force on that day, `year` a fiscal year (Oct 1 to Sep 30); omit both for the current fiscal year') and routes non-CONUS queries to the OCONUS endpoint. It does not address when to prefer this over the GSA per diem siblings or search_dtmo_perdiem, so routing among the broader per diem family 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?

With no annotations, the description carries the full behavioral burden and does disclose the returned rate components: lodging, local and proportional meals, incidentals, and maximum per diem per season. It does not mention pagination behavior, the verification_url option, or explicitly state that the operation is read-only, leaving some behavioral context to the schema or inference.

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 purpose and return contents, then moves efficiently into filter and date/year semantics. It is appropriately sized, with only minor redundancy between the opening 'Get perdiem OCONUS' and the following expansion.

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?

Because there is no output schema, the description usefully explains the return values, including lodging, meal rates, incidentals, and maximum per diem. It is complete enough for the main call pattern, though it omits pagination and verification_url details that would make it fully self-contained for all seven parameters.

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

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

The description adds useful meaning for the required OCONUS ISO code and for the q, date, and year filters, including the fiscal-year boundary. However, with schema description coverage at 71%, it does not compensate for undocumented parameters such as limit and offset, and it only lightly overlaps with the already-described verification_url.

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

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

The description clearly states a specific verb and resource: get DoD per diem outside the continental U.S., covering foreign countries and selected U.S. territories. It distinguishes itself from CONUS per diem by explicitly saying 'outside the continental U.S.', but it does not name the closest sibling tools such as get_dtmo_perdiem_conus or search_dtmo_perdiem.

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 OCONUS scope and by the notes that 'date' selects rates in force on that day and 'year' selects a fiscal year, with both omitted for the current fiscal year. However, there is no explicit guidance on when to choose this tool over sibling tools like search_dtmo_perdiem or get_dtmo_perdiem_conus.

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

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

With no annotations, the description carries the full burden and does well: it discloses the 404-on-miss behavior, that FEMA publishes only the current list (no historical snapshots), and that `as_of` reflects snapshot date. It also warns that no rate data is returned. Missing auth/rate-limit or pagination context, so not 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?

Front-loaded with the resource and the 404 behavior, then background, then the cross-tool recommendation. The statutory preamble about the Hotel and Motel Fire Safety Act is contextually useful for why the tool matters but is the least load-bearing sentence.

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?

No output schema exists, so the description must convey return shape; it does so adequately by identifying the returned property record, the `as_of` snapshot field, and the explicit absence of rates. An agent has enough to call and interpret it correctly.

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

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

Schema coverage is 100% and the sole parameter is fully documented there (format, example, case-insensitivity). The description adds domain framing ('Each property on the list has a FEMA ID') but no syntax or format detail beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb and resource: 'Return the property registered under a FEMA ID.' The single-record-by-identifier scope is clearly distinguishable from the sibling search_fema_hotels and get_fema_hotels_by_state_city/zipcode lookups, though those siblings are never 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?

Gives clear selection context ('Each property on the list has a FEMA ID') and explicitly routes the agent onward: 'This endpoint returns no rates: combine it with the GSA per diem lookups for the lodging ceiling.' No explicit when-not-use statement or named alternative for bulk/location lookup, which keeps it below a 5.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: result ordering (city then name), pagination semantics with default 50 / max 200, the meaning of `total`, 404 on unsupported state codes, empty results for non-matching cities, and that FEMA publishes only the current list with an `as_of` snapshot date. It also discloses a key negative trait — no rates returned.

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 core operation, then pagination, then matching rules, then domain context. Four paragraphs are slightly more than strictly needed — the Fire Safety Act background is useful motivation but could be tightened — though nothing is redundant 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?

No output schema exists, and the description compensates by naming the returned fields it references (`results`, `total`, `as_of`) and their meaning. Together with the 404 and empty-list behavior, an agent has everything needed to call and interpret the response.

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 real value: the enumerated set of accepted state codes (50 states, DC, AS/GU/MP/PR/PW/VI), the 404 consequence for others, and a concrete partial-matching example ('york' matches New York and Yorktown). It restates limit defaults from the schema, keeping it just under a 5.

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+resource+filter: FEMA-listed properties by state, optionally filtered by city. It is clearly distinguishable from siblings like get_fema_hotels_by_zipcode, get_fema_hotel_by_id and search_fema_hotels by its geographic key.

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?

States the context in which the tool is appropriate (federal traveler lodging reimbursement under the Hotel and Motel Fire Safety Act) and points to GSA per diem lookups for rates since this endpoint returns none. It never explicitly names a sibling as the alternative for other access patterns (e.g. zip code), so the routing guidance is a 4 rather than a 5.

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

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

With no annotations present, the description carries the full burden and delivers: ordering by name, ZIP+4 normalization to five digits, empty results for a known-but-unlisted ZIP versus a 404 for an unknown ZIP, the point-in-time nature of `as_of`, and the absence of rate data. These are exactly the behaviors an agent needs before and after invocation.

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 core scope statement is front-loaded, and the three paragraphs each contribute distinct information (scope/ordering, path semantics/error behavior, regulatory context and companion tools). It runs slightly long, but 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?

There is no output schema, yet the description covers the return shape (`results` list, name ordering, FEMA ID, `as_of` snapshot date) and the error/empty distinction, plus the expected follow-up call for rates. That is sufficient for an agent to call and interpret this single-parameter endpoint 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% and the parameter already has examples, so the baseline is 3. The description adds genuine semantics beyond the schema by explaining the normalization rule (ZIP+4 truncated to the first five digits) and the differing outcomes for known-empty versus unknown ZIPs.

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 opening line states a specific verb and resource ('FEMA-listed properties by ZIP code') and the body confirms listing behavior ordered by name. It is clearly distinguishable from siblings like get_fema_hotel_by_id (single property) and get_fema_hotels_by_state_city (different key).

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 clear context for when this lookup matters (reimbursement eligibility under the Hotel and Motel Fire Safety Act) and tells the agent to combine it with GSA per diem lookups for the lodging ceiling. It stops short of explicitly contrasting the ZIP key against search_fema_hotels or the state/city variant.

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

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

No annotations exist, so the description carries the burden and does reasonably well: it discloses the default-year behavior, the historical data floor of FY2022, the two rate schedules, and what the payload contains. It does not cover failure modes (e.g., an unknown SIN) or the role of the verification_url flag, which is left to the 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?

Front-loaded with the core purpose, then defaults, then data availability — a sensible information order. The opening phrase duplicates the tool name and the second sentence repeats 'GSA Fleet vehicle leasing rates', a small amount of waste but nothing obstructive.

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 correctly states the returned values (monthly lease rate and rate per mile), and it scopes the data by schedule and fiscal year. The one gap is behavior for invalid or unsupported SIN/year combinations, but for a simple read-only lookup this is close to complete.

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

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

Schema coverage is 75%, and the description adds meaning the schema lacks: what happens when 'year' is omitted and the earliest year that will resolve. It also characterizes the unit of 'sin' (a vehicle type) and the standard/europe split, though the latter is largely restated from the schema's enum description.

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

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

Specific verb and resource: 'Return the GSA Fleet vehicle leasing rates (monthly lease rate and rate per mile) for the vehicle type identified by its Standard Item Number (SIN)'. Names the scope (standard vs europe rate schedule) and even the returned metrics, so no sibling tool could be mistaken for it.

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 the key selection condition ('If year is not specified, the current fiscal year's rates will be returned') and the availability window ('Rates are available from fiscal year 2022'), which tells the agent when a year lookup is valid. No explicit exclusion of alternatives, but no sibling covers fleet leasing rates, so routing ambiguity is minimal.

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

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

With no annotations, the description carries the disclosure burden and does it well: it defines the destination abstraction, explains the ID 0 fallback, gives the default-date behavior, and states exactly what the response contains (seasonal lodging rate plus M&IE rate). Auth requirements, error behavior, and whether historical dates are supported are not mentioned.

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

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

Well front-loaded: the core action is the first sentence and the destination/ID caveats follow in logical order. The leading bare line "GSA per diem rate by destination" duplicates the title and the next sentence, costing a little tightness.

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, so the description takes on return-value disclosure and does so precisely (lodging rate for the date, M&IE rate, optional verification URL). For a single-record read lookup, everything an agent needs to invoke it correctly is 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 already 100%, so the baseline is 3; the description still adds genuine meaning beyond it — the semantic nature of `destination_id` (a GSA rate area that may span a county or the whole CONUS area) and the default behavior for an omitted `date`, which the schema does not state.

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 ("Return the GSA per diem rate") scoped by destination and date, and immediately clarifies that a destination is a GSA rate area rather than a municipality. This distinguishes it from siblings like get_gsa_perdiem_by_zipcode, get_gsa_perdiem_by_state, and get_destinations without needing 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?

Explicitly routes the agent to `GET /v1/gsa/destinations` to resolve a destination ID, and states that ID 0 means Standard CONUS and that omitting `date` returns today's rate. It does not, however, say when to prefer this tool over the by-zipcode or by-state variants, so the sibling selection is only partially covered.

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

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

With no annotations, the description carries the full burden and does well: it discloses the Standard CONUS fallback when no non-standard rate exists, the 404 behavior for unsupported state codes, case-insensitive partial matching, and the today-default. It omits pagination/response size behavior, so not a 5.

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

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

The scope statement leads, followed by filtering and fallback behavior; every paragraph adds actionable information. It is somewhat longer than strictly necessary, with a little redundancy between the opening line and the first sentence.

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 by describing what each result contains (seasonal lodging rate plus M&IE rate) and the inclusion of a verification URL. That is enough for an agent to call and interpret 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; the description still adds value by explaining the date-omission default, the matching semantics of `location`, and the effect of `verification_url` on the response. These go slightly beyond the schema's own 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?

States a specific verb and resource ('Return every GSA destination rate in a state that applies on a specific date') and scopes it to CONUS destination rates. It is clearly distinguishable from the zipcode, destination, and state_year siblings by the state-only, single-date framing.

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 when rates default to today if `date` is omitted, when to use `location` to narrow results, and that it is CONUS-only with 404 on unknown state codes. It does not explicitly name the sibling tools (e.g. get_gsa_perdiem_by_state_year) as alternatives, which keeps it below 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?

No annotations are provided, so the description carries the full burden, and it does substantial work: it discloses the response shape (per-month lodging rate plus daily M&IE rate), the fiscal-year boundary definition, case-insensitive partial matching, and what `verification_url` adds. It stops short of pagination, ordering, or behavior when the state/year combination has no data.

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 scope statement is front-loaded and the follow-on sentences each add information (return shape, fiscal-year definition, filter behavior). There is mild redundancy between the title line and the first body sentence, and the fiscal-year explanation is repeated in the schema, keeping it off a 5.

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

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

With no output schema and no annotations, the description is the only place the return shape is explained, and it does explain it (monthly lodging + daily M&IE). Combined with the fiscal-year definition, an agent can call this correctly; only edge-case behavior (empty results, ordering) is missing.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema, including the fiscal-year definition, partial-match semantics, and the verification_url effect. The description restates rather than extends that, so the 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 opens with a specific verb+resource ('GSA per diem rates by state and fiscal year') and the first body sentence pins the scope: every GSA destination rate in a state for a US fiscal year. That distinguishes it from get_gsa_perdiem_by_state (no year) and get_gsa_perdiem_by_destination, but it never names those siblings, so the agent must infer the boundary.

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 only implied by the scope statement and by the optional `location` filter. There is no explicit 'use this when you need all destinations in a state' versus 'use get_gsa_perdiem_by_state for the latest year' guidance, and no mention of prerequisites 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?

No annotations are provided, so the description must carry the burden — and it does well: it discloses ZIP+4 normalization, multi-destination result behavior without auto-selection, fallback to Standard CONUS when no non-standard destination exists, and the verification_url output. It omits error/invalid-ZIP behavior and any rate-limit or freshness caveats beyond 'today's rates'.

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, then progressively details multi-destination handling and path semantics. Mostly earns its space, though the ZIP/ZIP+4 normalization sentence duplicates the schema and could be trimmed.

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 explains return contents (seasonal lodging rate and M&IE rate) and multi-result behavior, which is sufficient for correct use. It lacks error-case handling, but the core information an agent needs to call and interpret the tool is 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 adds real meaning beyond the schema by stating the default behavior when `date` is omitted (today's rates) and reinforcing ZIP+4 normalization, which materially helps invocation.

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 ('Return every GSA destination rate') and resource (per diem rates by ZIP code and date). Scope is precise and distinguishes it from siblings like get_gsa_perdiem_by_destination or get_gsa_perdiem_by_state by naming ZIP-code and single-date targeting.

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 clear operating context: date is optional with a stated default, and multiple destinations per ZIP are explained with a suggested disambiguation approach (county or geocoder). It does not name sibling alternatives (e.g., the year-based variant) or exclusions, so it falls short of full when/versus guidance.

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

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

With no annotations, the description carries the burden well: it discloses the one-to-many ZIP-to-destination behavior, that no destination is auto-selected, the Standard CONUS fallback for non-standard ZIPs, and ZIP+4 normalization. It omits auth/rate-limit context, but for a read-only lookup the behavioral disclosure is notably above average.

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 core capability is front-loaded in the opening sentence and each following paragraph adds a distinct, non-redundant fact. It is slightly long for a three-parameter lookup, but 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?

With no output schema, the description does the necessary work of explaining what comes back — monthly lodging rates for the fiscal year, the M&IE rate, and a `results` collection covering every applicable destination. Only response-shape details (field names, ordering) are left implicit, which is minor.

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

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

Schema coverage is 100%, so all three parameters are already documented in the schema. The description reinforces ZIP+4 normalization and the fiscal-year definition but adds little syntax or format detail beyond what the schema states; 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 names a specific verb and resource — GSA lodging rates for every month of a US fiscal year plus the M&IE rate for a ZIP code — which is unambiguous. It doesn't explicitly distinguish itself from near-siblings like get_gsa_perdiem_by_zipcode or get_gsa_perdiem_by_state_year, so an agent must infer the year-scoped variant is the differentiator.

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 useful downstream guidance (a ZIP can map to multiple destinations, the API won't pick one, use the county or a geocoder) and explains the Standard CONUS fallback. However, it never states when to prefer this tool over sibling tools such as get_gsa_perdiem_by_zipcode or get_gsa_perdiem_by_destination, leaving the choice to inference.

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

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

No annotations are provided, so the description must carry the full behavioral burden, but it discloses nothing about what is returned, freshness, ordering, pagination, 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?

The three-word description contains no waste but is under-specified rather than concise. It is front-loaded only in the trivial sense that there is almost nothing to front-load.

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, no output schema, and no parameter definitions, the description provides no information an agent needs to call the tool meaningfully. It does not explain what 'publications' contains or how results are shaped.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter semantics to document or compensate for.

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 is a bare noun phrase that essentially restates the tool name. It does not state what a 'data publication' is, what 'latest' means, or how this differs from the dozens of allowance/perdiem 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?

There is no guidance on when to call this tool, what question it answers, or which sibling to use instead for allowance or per-diem data. An agent has no basis for selecting it.

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

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

With no annotations, the description carries the full burden. It usefully discloses that CONUS returns five standard M&IE tiers, that oconus returns the generic total table, and that omitting date defaults to today. It does not mention whether this is purely read-only, how errors behave, or what the response shape looks like, so transparency is adequate but incomplete.

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 short and front-loaded with the core behavior. The leading 'M&IE meal breakdowns' is somewhat redundant with the tool name, but the remaining sentences are efficient and 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?

There is no output schema, so the description must explain return content; it does so by naming the breakfast/lunch/dinner/incidental breakdown, the five CONUS tiers, and the oconus generic table. Defaults for date and region are also covered. Minor gaps remain around parameter 'total' and verification_url behavior, but the core lookup is complete.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description adds meaning for region and date defaults, but does not explain the total or verification_url parameters beyond what the schema already provides. This meets the baseline for high schema coverage.

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

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

The description clearly states a specific resource and output: daily M&IE totals broken into breakfast, lunch, dinner and incidental expenses. It doesn't explicitly differentiate itself from close siblings like get_dtmo_perdiem_conus or get_dtmo_perdiem_oconus, but its purpose is still understandable 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 useful parameter-selection guidance: CONUS is returned by default, and region=oconus selects the generic DTMO/DSSR table. However, it doesn't say when to use this tool instead of siblings such as get_dtmo_perdiem_conus or get_dtmo_perdiem_oconus, leaving usage implicit.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the default behavior when the date is omitted, but says nothing about return shape (per-mile amounts, currency, multiple rate categories), pagination, or authentication/rate-limit characteristics — gaps that matter for a tool with no output 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 body is two efficient sentences that front-load the resource and then the default-date behavior. The leading fragment 'POV mileage reimbursement rates' duplicates the first sentence and is the only wasted line.

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?

Three optional parameters, no annotations, and no output schema mean the description should explain what comes back and how the 'type' filter affects results. It explains the resource and the date default, but the return payload and the multi-rate-type behavior are 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 coverage is 100%, so the schema already documents 'date', 'type', and 'verification_url'. The description adds one genuinely new semantic — that omitting the date yields today's rates — but says nothing about the 'type' filter or verification_url, leaving the baseline of 3 appropriate.

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

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

The description uses a specific verb and resource: 'Return the privately owned vehicle (POV) mileage reimbursement rates in effect on the given date.' An agent can tell this is a rate-lookup tool rather than a calculation, but the description never names the closely related sibling 'calculate_mileage_reimbursement', so differentiation is left implicit.

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 only implied: the tool is for looking up rates, and the description explains the no-date fallback ('today's rates will be returned'). It gives no explicit guidance on when to pick this over calculate_mileage_reimbursement or the per-diem tools, and no exclusions or prerequisites are stated.

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

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

With no annotations, the description carries the full burden and does so: it discloses matching semantics (word-contains for areas, exact case-insensitive for counties/cities, optional trailing 'county'), the RUS fallback, that multiple areas can be returned for one name and that the duty station disambiguates, and that territories are excluded.

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 and the code-return value are front-loaded and nearly every sentence carries operational detail. There is mild redundancy ('keeps the areas whose name contains every word' is restated later as 'Area names keep matching on any word they contain'), and the trailing caveats could be tightened.

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?

No output schema exists, yet the description explains the result shape (`matched_places` listing the counties and cities behind each result) and covers the tricky failure modes (multiple matches, RUS, misspellings, uncovered territories). An agent has everything needed to call and interpret it.

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 goes well beyond the terse schema text: it defines how `location` matches area names versus county/city names, the optional 'county' suffix, case-insensitivity, and the non-obvious rule that `state` only narrows `location` and is inert without 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 and resource ('List the locality pay areas of the latest pay year') plus the return payload ('the code to use on the pay endpoints'), and the opening line adds the optional county/city scoping. It also distinguishes itself from the county-lookup sibling by directing payroll use to '/v1/opm/localities/county/{fips}'.

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 (resolve a GS locality code for pay endpoints), when-to-use-something-else (payroll should use the county endpoint because OPM does not publish city data), and an explicit exclusion caveat (empty result does not mean RUS; territories are not covered). The dependency rule 'state has no effect without location' is stated outright.

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

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

With no annotations present, the description carries the full burden and does so thoroughly: unlisted counties collapse to RUS, Alaska/Hawaii return state areas, unknown codes and Connecticut planning regions return 404, territory codes return 404, and the Burlington County/military-site quirk is called out explicitly. These are exactly the non-obvious behaviors an agent cannot infer from schema or name.

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

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

Purpose is front-loaded and the edge-case paragraph is dense with non-redundant information. It loses a point for the leading fragment 'GS locality pay area of a county,' which duplicates the sentence that follows (and appears to be a typo for GSA), plus the Burlington County detail, which is useful but disproportionate to a single county's military sites.

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, so the description must convey the return value, and it does: a locality pay area name, with `RUS` as the defined fallback and state areas for AK/HI. Complete for correct invocation and interpretation, though it never states the actual response shape (e.g., whether the area code and name are both returned).

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

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

Schema coverage is 100% and the schema already defines the five-digit FIPS pattern, so the baseline is 3. The description earns a notch above by adding semantic constraints the schema cannot express: which codes are rejected (Connecticut planning regions, territory codes) and a concrete example ('34005') whose behavior is spelled out.

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 ('Return the locality pay area of a county') and pins the scope to 'the latest pay year, using OPM's own definitions.' Combined with the name, an agent can immediately distinguish this single-county lookup from the broader sibling get_opm_localities list 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 scope is clear enough to imply usage (per-county FIPS lookup), and the 404/fallback rules tell the agent a lot about edge conditions. But it never names an alternative — get_opm_localities, get_opm_pay, or search_opm_pay — or states when an agent should prefer one of those over 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?

No annotations are provided, so the description carries the burden. It discloses useful behavior beyond the schema, including that it returns the latest table ordered by grade and step and returns 404 for an unknown code, though it does not explicitly restate that this is a read-only lookup.

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 short and front-loaded: the first line names the operation, and the following sentences add only the necessary return behavior, filtering behavior, and special locality codes. There is no wasted 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?

For a simple lookup tool with 3 parameters and full schema coverage, the description is nearly complete: it covers ordering, filtering, 404 behavior, and special locality codes. It does not spell out the exact returned fields, but the pay-table output is reasonably implied and 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 coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explicitly documenting `RUS` for Rest of U.S. and reinforcing `GS` as the base table, which helps the agent choose the correct locality code 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 states a specific verb and resource: return the latest GS pay table for a locality pay area, and it explains that grade and step narrow the rates. It is clear, but it does not explicitly distinguish itself from siblings such as search_opm_pay or get_opm_localities.

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 useful value guidance for `locality_code` (`GS` for base pay, `RUS` for Rest of U.S.), so the intended usage is implied. However, it does not explicitly say when to use this tool instead of alternatives like search_opm_pay or get_opm_localities.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing beyond the resource name. It does not state that this is a read-only lookup, whether the result is a daily lodging/M&IE rate, how missing-country data is handled, or what the response 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?

The description is extremely short and front-loaded, but it is a noun fragment rather than a complete, self-standing sentence. Its brevity borders on under-specification rather than efficient communication.

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 and no annotations, yet the description does not explain the return values, date-selection behavior, or what happens when a country lacks a DSSR rate. For a per diem lookup tool with several sibling alternatives, this leaves important context 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 description coverage is 100%, so the schema already explains country_iso_code, date, and verification_url in detail. The description adds no parameter meaning beyond that, so 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 identifies a specific resource ('DSSR per diem') and scope ('by country'), but it is a terse fragment without an explicit verb. It partially distinguishes this tool from siblings like get_perdiem_allowance_by_location and get_gsa_perdiem_by_destination, but does not name or contrast with any 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?

There is no guidance on when to use this tool versus the many sibling per diem tools (e.g., by location, by postcode, GSA/DTMO alternatives). The phrase 'by country' implies country-level lookups, but no alternatives, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full burden, yet it adds nothing behavioral: no statement that this is a read-only lookup, no note on whether partial/fuzzy location names return multiple matches (the schema's openapi_examples show a 'toky' partial match, but the description is silent), no mention of the optional date's effect on results, and no indication of response shape.

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?

At six words there is zero waste and the key is front-loaded, but the brevity is under-specification rather than efficiency — the single fragment cannot carry the routing or behavioral load this tool needs.

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 4-parameter tool with no annotations and no output schema, the description leaves too much unsaid: the meaning of DSSR versus GSA/DTMO/FEMA per diem, whether results are single or multiple, and how the optional date and verification_url change output all go unexplained.

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 location, country_iso_code, date, and verification_url thoroughly, including the ZZ special case and the get_countries resolution hint. The description's only contribution is the phrase 'by location name', which is redundant with the schema. 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 fragment 'DSSR per diem by location name' names the resource (DSSR per diem) and the lookup key (location name), which is enough to guess it returns per diem rates for a location. But it is not a full sentence, never expands the DSSR acronym, and never states what is actually returned (rates, allowances, lodging/meals breakdown), so an agent cannot cleanly separate it from siblings like get_perdiem_allowance, get_allowances_by_location, or get_dssr_locations.

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

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

There is no when-to-use guidance, no exclusions, and no mention of any alternative. With over 40 siblings, including several near-identical per diem lookups (by_postcode, get_gsa_perdiem_by_destination, get_dtmo_perdiem_conus), the absence of routing guidance is a real gap.

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

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

No annotations are provided, so the description carries the full burden, yet it says nothing about what DSSR means, how the date parameter defaults when omitted, what the payload looks like, or whether results vary by date. The only behavioral hint (verification URL) lives in the schema, not the description.

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?

It is short but under-specified rather than concise: a four-word fragment with no sentence structure, no punctuation, and no front-loaded statement of what the tool returns. Brevity here costs clarity rather than saving it.

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 4-parameter tool with no annotations and no output schema, the description supplies no domain context, no return-value expectation, and no indication of how date affects results. Everything an agent knows must come from the schema alone, leaving the description functionally incomplete.

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

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

Schema description coverage is 100% and the schema itself is rich: it constrains postcode to a 5-digit integer, lists ISO examples, notes ZZ handling, and routes country resolution to get_countries. The description adds nothing beyond that, 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?

The phrase names a resource (DSSR per diem) and a lookup dimension (post code), so the agent knows roughly what it retrieves. However it is a fragment with no verb and no differentiation from the many sibling postcode/per-diem tools (get_perdiem_allowance_by_location, cola_calculator_by_postcode, get_gsa_perdiem_by_zipcode), so an agent cannot confidently pick it over those.

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

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

There is no when-to-use guidance, no prerequisite, and no named alternative among a dense sibling set that includes several other per-diem-by-postcode/zipcode tools. The 'by location post code' phrasing only hints at the input shape, not at selection criteria.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing — not whether the user is the caller or an arbitrary ID, not authentication requirements, not error behavior. Zero behavioral context is given for a tool with no safety hints whatsoever.

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 words with no front-loaded detail. This is under-specification rather than conciseness — brevity at the cost of all useful 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?

With no annotations, no output schema, and no parameter documentation, the description is the only channel for information and it delivers none. An agent cannot determine what this returns or whether it is safe to 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?

The tool takes zero parameters, so the schema needs no explanation and the description cannot add parameter meaning. Baseline 4 applies; the description neither helps nor hurts here.

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?

"Get User" merely restates the tool name and adds no verb-plus-resource specificity. In a sibling set composed entirely of travel-allowance lookups (per diem, mileage, FEMA hotels, OPM pay), it is unclear what kind of "user" this returns or how it relates to that domain.

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

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

There is no stated condition for when to call this tool, no prerequisites, and no reference to any alternative. Nothing distinguishes it from the ~40 sibling lookup tools, so an agent has no basis for selection.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: multi-state results are returned as a set rather than a single chosen state, ZIP+4 is normalized to five digits, and the normalized value is echoed back. It leaves out error behavior (unknown ZIP), rate limits, and the full response shape, 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?

Front-loaded with the core operation, then scope, then the alternative, then format rules. Slightly padded by the 'This is a geographic metadata endpoint' framing, but every sentence contributes disambiguation or format guidance.

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

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

For a one-parameter lookup with no annotations and no output schema, the description covers purpose, sibling disambiguation, input normalization, and return-value expectations sufficiently. Only the failure mode for an unmatched ZIP is 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 coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema: ZIP+4 is truncated to five digits before lookup, the normalized ZIP is returned, and leading zeroes make the string type significant. That goes beyond 'US ZIP (12345) or ZIP+4 (12345-6789)'.

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 ('Get ZIP code metadata', 'Look up every state associated with a US ZIP code') and immediately scopes the result to state association, which no sibling tool does. The mention that it does not return per diem rates cleanly separates it from the many perdiem-by-zipcode 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 names when-not-to-use and the alternative ('Use `/v1/gsa/perdiem/zipcode/{zipcode}` for rates'), and describes the decision-relevant context (multi-state ZIPs, no automatic state selection). This is a clear routing instruction rather than implied usage.

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

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

With no annotations, the description has to carry the behavioral burden. It discloses the fiscal-year meaning and that omitting date/year defaults to the current fiscal year, which is useful, but it does not cover return shape, pagination, behavior when both date and year are supplied, or whether q is optional.

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 text is short and front-loads the purpose. The first line acts as a heading, and the remaining sentences give the most important scoping and date/year behavior without 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?

The description is adequate for identifying the tool and its main date/year behavior, but for a tool with no output schema and 4 optional parameters it does not explain the response shape, q omission, or how date and year interact. Those are meaningful gaps for an agent trying to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by giving concrete location examples and explaining that date selects rates in force and that omitting date/year uses the current fiscal year; however, it does not explain q omission or verification_url.

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 gives a clear verb and resource ('Search ... Department of Defense per diem') and scopes it to location, country, or state names across CONUS and OCONUS. It does not explicitly distinguish this from siblings such as search_perdiem or get_dtmo_perdiem_conus/oconus, so it is clear but not fully sibling-differentiated.

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 implies usage through input examples and the date/year explanation, but never states when to use this tool versus search_perdiem, get_dtmo_perdiem_conus, get_dtmo_perdiem_oconus, or the GSA per diem tools. No explicit exclusions or alternatives are provided.

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

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

With no annotations to lean on, the description carries the full burden and does so well: it discloses substring-only matching, the absence of fuzzy matching (with a concrete failure example), that single-character words are ignored, that an unlisted state code returns 404, the ordering rule, and that a miss yields an empty results list. That is exactly the behavioral detail an agent needs before calling.

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 matching semantics are front-loaded in the first sentence and the paragraphs are tight and purposeful. The reference to FEMA IDs is mildly gratuitous given no output schema is published, but the statutory context paragraph genuinely explains why the list exists.

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

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

For a tool with no annotations and no output schema, the description covers the return shape (results plus a total count), pagination defaults and ceilings, ordering, empty-result behavior, and the as_of snapshot date. Nothing an agent needs to invoke it or interpret the response is missing.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description genuinely adds meaning beyond the schema: it explains how multiple q words combine, shows worked examples, specifies limit's 50 default and 200 cap alongside offset, and documents the 404 outcome for an invalid state code.

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 opening line names a specific verb and resource ("Search FEMA-listed properties by name and town"), and the matching rules that follow make the name-plus-city scope unambiguous. It is implicitly distinct from siblings such as get_fema_hotel_by_id or get_fema_hotels_by_zipcode, but it never explicitly names those alternatives, so sibling differentiation is left to inference.

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 second paragraph supplies real decision context: federal travelers need a listed property to be reimbursed, and the tool returns no rates so it should be combined with the GSA per diem lookups. What is missing is explicit routing between this free-text search and the state/city or zipcode lookup siblings — an agent must infer when to prefer each.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses latest-table selection, empty results on no match, and the important caveat that no match does not mean Rest of U.S.; it omits read-only/auth/rate-limit details and result ordering.

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 purpose, then matching rules, then a caveat. Three short paragraphs with no filler, though the 'No match' behavior is restated in different forms.

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?

No output schema and no annotations, but the description covers purpose, input matching, empty-result behavior, and a key semantic caveat. It leaves result fields and ordering unstated, which is a minor gap for a search tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema: every q word must match case-insensitively in the area name or code, and grade/step narrow the returned rates.

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 ('Search') and resource ('GS pay by locality area'), and clarifies it returns the latest pay tables. It does not explicitly name the sibling get_opm_pay or get_opm_localities, so sibling differentiation is left to inference.

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?

Explains how q matching works and warns that county/town coverage is not searched, but never states when to use this tool instead of get_opm_pay or get_opm_localities. Usage is implied rather than explicitly routed.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the default date, response effective_date semantics, HTTP 422 for invalid queries, and HTTP 404 for no matches. This is unusually complete for a search tool without 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 short, front-loaded with the core action, and organized into useful search, date, and error-behavior details. Every sentence adds information 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?

For a two-parameter search tool with no output schema and no annotations, the description covers usage, date semantics, validation, and no-match behavior. It does not describe the shape of returned rate data, but it is otherwise complete enough to invoke correctly.

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

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

Schema coverage is 100%, so the schema already documents q and date formats. The description adds meaningful semantics beyond the schema by explaining that date selects effective and seasonal rates and defaults to today.

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: searching DSSR per diem by country/location name. The 'DSSR' qualifier helps distinguish it from sibling per diem search tools such as search_dtmo_perdiem, though it does not explicitly name alternatives.

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

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

It gives clear usage context: global search by case-insensitive substring, with date selecting effective and seasonal rates. It does not explicitly say when to use this versus sibling tools like postcode-based or GSA/DTMO per diem lookups.

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