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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safe-read nature is covered. The description adds that it returns a bbox and optionally full boundary geometry, which is useful, but it does not disclose coordinate reference system, units, or potential performance cost of requesting full geometry.

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, front-loaded sentence with no filler. Every word earns its place and the core return value is stated first.

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 output schema exists, so return-value details are not required in the description. However, with no parameter descriptions in the schema and an unexplained zoom parameter, an agent may not know what zoom controls or what area id format is expected. This is adequate for a simple lookup but leaves a couple of gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'id' and hints at includeGeometry via 'optional full boundary geometry', but 'zoom' is completely unexplained and 'tool' is a constant. For a parameter-semantics standpoint, this leaves a meaningful gap in a low-coverage schema.

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

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

The description uses a specific verb ('Return') and a clear resource ('bbox and optional full boundary geometry for a given area id'). It is immediately distinguishable from sibling admin tools like admin_lookup_find_by_name or admin_lookup_containing_areas, which address different lookups.

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

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

The phrase 'for a given area id' implies the use case: the agent should call this when it already has an area id and needs its bounding box or boundary. However, it gives no explicit guidance about when not to use it or which sibling to prefer, so usage context is only implied rather than 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?

The annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds minimal behavioral context beyond that, mainly clarifying the input type; it does not describe return shape, coordinate system, or potential edge cases, but it does not contradict the annotations.

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

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

The description is one short, front-loaded sentence with no filler or repetition. It states the action, resource, and input in a compact way.

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?

This is a simple two-parameter, read-only lookup with an output schema present, so the description is close to adequate. Still, it leaves out useful context such as what administrative levels are returned (e.g., country, region, district) and whether the coordinates use a particular datum, which could matter for correct invocation.

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

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

Schema description coverage is 0%, but the parameter names 'lat' and 'lon' are fairly self-explanatory, and the description reinforces them by calling the input 'a point (lat/lon)'. It does not provide range, format, or coordinate reference system details, but it does enough to map the parameters to their meaning.

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 specific verb ('Return') and resource ('containing administrative areas') with a clear input ('a point (lat/lon)'). It is clear what the tool does, but it does not explicitly differentiate itself from sibling lookup tools like admin_lookup_find_by_name or admin_lookup_area_geometry.

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

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

The phrase 'for a point (lat/lon)' implies the primary use case: when you have coordinates and need the administrative areas containing that point. However, it gives no explicit guidance on when not to use it or which sibling tools to choose instead.

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

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

Annotations already declare readOnly and idempotent hints, so the description's job is lighter. It adds useful behavioral context by clarifying the response granularity ('ids and bbox summaries') and by signaling that full boundary geometry is not the expected return here. It does not discuss default matching behavior, but the annotations cover the safety profile.

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, front-loaded sentences with no filler. The first sentence states function and result, and the second provides routing to the relevant sibling. Every sentence earns its place.

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

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

The output schema covers return values, and the annotations cover read-only/idempotent behavior, so the description does not need to repeat those. However, for an 8-parameter input schema, most parameters remain undocumented, and the relationship between includeGeometry and the geometry-returning sibling is unclear. It is adequate but not fully complete.

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

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

Schema description coverage is only 13%, so the description must compensate for undocumented parameters. It only clarifies the name/text aspect ('Search ... by name') and leaves match, levels, limitPerLevel, includeGeometry, and limit largely unexplained. The presence of includeGeometry also creates ambiguity against the instruction to use another tool for full boundary geometry.

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 concrete action ('Search administrative areas by name') and the result ('returns ids and bbox summaries'). It also distinguishes this tool from the geometry-returning sibling by explicitly routing full boundary geometry to admin_lookup.area_geometry, so an agent can tell the two apart.

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 context for when to use this tool: when searching by name and wanting ids/bbox summaries rather than full geometry. It names an alternative for the adjacent case ('Use admin_lookup.area_geometry for full boundary geometry'), though it does not discuss other lookup variants such as search_cache or containing_areas.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds minor context by listing the output content (levels, datasets, counts), but it does not disclose the side effects or semantics of the 'refresh' parameter, which could have behavioral implications beyond the read-only guarantee.

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

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

The description is a single direct sentence with no fluff, and the core purpose is front-loaded. It is concise, but it is also so terse that it omits useful semantic details, making it less than ideal for the full 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?

Although an output schema exists and annotations cover read-only behavior, the description does not provide enough context for correct invocation. The meaning of 'refresh' and when to use this tool versus cache-related siblings are missing, leaving a meaningful gap.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. 'tool' is self-evident from the const, but 'refresh' is ambiguous and could mean clearing, reloading, or rechecking the cache. The description provides no added meaning over the bare schema.

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

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

The description states a clear verb ('Return') and specific resource ('boundary cache status'), including the data points returned (levels, datasets, counts). It does not explicitly distinguish itself from the sibling ons_geo_cache_status, but the boundary-specific wording is sufficient to differentiate it from other cache-related tools.

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

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

There is no guidance on when to use this tool versus alternatives like admin_lookup_search_cache or ons_geo_cache_status. No context is provided about typical use cases, prerequisites, or when not to use it.

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

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

The description aligns with the readOnly and idempotent annotations by indicating a non-mutating lookup. It adds little behavioral detail beyond the name – no mention of ordering, whether the chain includes the current area, or depth limits – but the annotations already cover the safety profile.

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

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

The description is a single efficient sentence that gets to the point immediately. No filler or redundant wording.

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

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

Given the simple signature and presence of an output schema, the description is minimally adequate. However, it does not explain the meaning of 'ancestor chain' or how it relates to similar lookup tools, so it misses context an agent might need to select it confidently.

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

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

With 0% schema description coverage, the description must clarify parameters. It does clarify that `id` is an 'area id', which adds semantic meaning beyond the raw string type. However, it does not specify the format or source of the area id, leaving some ambiguity.

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 ('Return') and resource ('ancestor chain'), clearly identifying the output. However, it does not distinguish this from the similarly named sibling admin_lookup_containing_areas, so an agent may not know which to choose without inspecting schemas.

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

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

The description offers no guidance on when to use this tool versus alternatives like admin_lookup_containing_areas or admin_lookup_find_by_name. There are no conditions, exclusions, or alternative references, leaving the agent to infer usage.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description's job is lighter. It adds the 'boundary cache' context and the search fields, but doesn't mention output details or how fallbackLive affects behavior. No contradiction with annotations.

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

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

One sentence, direct, and front-loads the core action. No fluff. Could add a bit more detail without harming conciseness, but it's appropriately short.

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 an output schema, so return format is covered, and annotations cover safety. However, the tool has 6 parameters with only 17% schema coverage, and the description doesn't explain how to use key parameters (query, level, limit). Sibling tools like admin_lookup_find_by_name suggest a specialized search, but the description doesn't position this tool for effective selection.

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

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

Schema description coverage is only 17% (only fallbackLive has a description). The description mentions id/name/level but doesn't map them to the 'query' parameter or clarify how 'level' works. With 6 parameters and minimal schema descriptions, the tool description needs to clarify how the search is performed, but it doesn't.

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

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

The description clearly states the action (search) and the resource (boundary cache), with the fields to search (id/name/level). This distinguishes it from sibling tools like admin_lookup_find_by_name, which likely search by name only. However, it doesn't explicitly contrast with similar lookup tools, so it's a 4 rather than a 5.

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

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

No guidance on when to use this versus alternatives. Sibling tools like admin_lookup_find_by_name, admin_lookup_get_cache_status, and admin_lookup_containing_areas suggest different purposes, but the description gives no contextual cues or exclusions. Agents must infer usage from the name alone.

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

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

Annotations already convey readOnlyHint and idempotentHint, so the bar is lower. The description adds useful context that this wraps an external public GOV.UK service and is experimental, implying possible volatility, but it does not discuss errors, rate limits, or data freshness.

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

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

One sentence with no filler; the experimental warning and jurisdiction are front-loaded. However, the brevity reflects under-description rather than efficient completeness.

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

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

For a 12-optional-parameter lookup tool, the description is too thin. It does not indicate which parameters are meaningful, how they relate, or when this tool is appropriate, so the agent must rely on an under-described schema and the output schema.

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

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

Schema description coverage is only 8%, and the description contributes no parameter guidance. It never explains postcode, street, town, propertyName, billingAuthorityReference, courtCode, or how these parameters should be combined, so an agent cannot construct a valid lookup from the description.

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

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

States a clear action ('lookup'), resource ('Council Tax band'), geography ('England/Wales'), and source ('public GOV.UK service'). It is more specific than the bare name, but it does not explicitly differentiate itself from sibling council_tax_query.

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

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

No guidance on when to use this tool versus council_tax_query or the other lookup tools. It mentions the service is experimental and public, but gives no prerequisites, exclusions, or example use cases.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds meaningful behavioral context: it specifies the data source (AddressBase Premium), the record type (Application Cross Reference), and the flag semantics (Council Tax and non-domestic rates). It also clarifies the activeOnly parameter's meaning via schema description, but the description itself doesn't add much beyond the schema. However, the description's mention of 'flags' and 'cross reference records' gives useful domain context beyond annotations.

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

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

A single, information-dense sentence that front-loads the verb, resource, and purpose. No wasted words. It earns its place by adding domain context that the schema and annotations do not provide.

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

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

Given the tool's moderate complexity (3 params, 1 required, output schema present), the description is sufficient for an agent to understand what the tool does and when to call it. The output schema exists, so return values need not be described. The only gap is explicit usage guidance versus alternatives, but the domain context and parameter semantics are clear enough for correct invocation.

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

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

Schema description coverage is 67%: the 'uprns' and 'activeOnly' parameters have descriptions, but the 'tool' const parameter is self-explanatory. The description adds meaning by explaining that UPRNs are used to query AddressBase Premium cross-reference records and that the output identifies Council Tax/non-domestic rates flags. This complements the schema's parameter descriptions, which already explain the activeOnly default and UPRN format.

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 ('Query'), a specific resource ('AddressBase Premium Application Cross Reference records'), a key parameter ('by UPRN'), and the purpose ('identify Council Tax and non-domestic rates flags'). This clearly distinguishes it from siblings like council_tax_band_lookup and os_places_by_uprn.

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: use when you need Council Tax/non-domestic rates flags for UPRNs. It does not explicitly state when not to use it or name alternatives (e.g., council_tax_band_lookup for band lookup, os_places_by_uprn for general address data). The sibling list provides context but the description itself gives no routing guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds only the 'locally mirrored' data-source context; it does not describe error behavior, availability of the item, or other runtime traits, but this is not a contradiction.

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 eight-word sentence that front-loads the action and object with no filler. It is appropriately concise for a simple single-argument read tool.

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

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

For a one-argument read-only tool with a rich output schema and readOnly/idempotent annotations, the description is nearly complete. The main missing context is where archiveId comes from and when to select the list sibling, but the schema and annotations cover the rest.

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

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

Schema description coverage is 0%, so the description bears the burden of explaining archiveId, but it never mentions the parameter or its format and provenance. The phrase 'one ... item' only weakly implies that archiveId identifies the item, leaving the agent without guidance beyond the name.

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

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

The description uses a specific verb ('Get detail') and a specific resource ('one locally mirrored LandIS archive item'). The singular 'one' differentiates it from sibling landis_archive_list_items and makes the tool's scope immediately clear.

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 does not state when to choose this tool over alternatives such as landis_archive_list_items, nor does it mention that an archiveId must first be obtained from a list/catalog call. There is no exclusion or alternative guidance, so an agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safe, read-only nature is covered. The description adds useful context by clarifying that items are locally mirrored and that triage classification is part of the result, but it does not disclose pagination behavior, filter semantics, or output size limits.

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

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

The description is a single, front-loaded sentence with no filler words. It states the core action and the notable output attribute efficiently. However, the brevity borders on under-specification, which costs it the top score.

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 six parameters, no schema descriptions, and no usage guidance, the description is too thin. It does not explain what distinguishes archive items, what triage classification means, how to narrow results, or how this relates to landis_archive_get_item. The output schema helps, but the agent still lacks enough context to call the tool confidently.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining six parameters: q, tool, limit, family, offset, and surfacingClass. The description only mentions listing archive items and triage classification; it does not explain what any parameter means, how filters interact, or how pagination works.

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 ('List'), a specific resource ('locally mirrored LandIS archive items'), and adds the distinguishing detail that triage classification is included. This differentiates it from related siblings like landis_archive_get_item (single item retrieval) and landis_catalog_list_products (catalog products, not archive items).

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 no explicit guidance about when to use this tool versus alternatives. 'Locally mirrored' and 'archive items' imply a scope, but there are no stated exclusions, prerequisites, or references to sibling tools such as landis_archive_get_item.

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

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

Annotations already mark the operation read-only and idempotent, so the description need not restate safety. It adds a small amount of context by naming the output facets (coverage, access tier, resource hints), but does not disclose pagination behavior, the meaning of 'MVP', or any operational caveats.

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 front-loaded sentence with no filler. It is concise, but the brevity comes at the cost of parameter and usage detail.

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

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

The tool has six optional parameters and pagination fields, yet the description gives no clue how to filter, paginate, or constrain the list. An output schema exists, so return structure is covered, but the description is otherwise too thin for correct invocation beyond the simplest 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?

All six parameters lack schema descriptions (0% coverage), and the description does not explain q, tool, limit, family, offset, or pageToken. The description provides no compensation for the schema gap.

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

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

The description uses a specific verb ('List') and a distinct resource ('LandIS MVP product registry'), and hints at the returned information (coverage, access tier, resource hints). It is clearly a catalog listing rather than a metadata or archive operation, though it does not explicitly contrast with sibling list tools such as landis_archive_list_items.

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 when-to-use, prerequisites, or exclusions are provided. The agent must infer from the name that this is the tool for LandIS products, with no guidance about when alternatives like landis_archive_list_items or landis_metadata_get would be more appropriate.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the input constraint (bbox or GeoJSON polygon) but does not describe output or other behavioral details beyond what the output schema provides. This is adequate given the annotations.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the purpose and input specification, making it highly 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?

The description is concise but lacks explicit guidance on whether both bbox and geometry can be supplied, or what happens if neither is provided. Since the schema marks both as optional, the 'or' phrasing could be ambiguous. The output schema exists, so return values are covered, but the input ambiguity is a gap.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the geometry parameter should be a GeoJSON Polygon or MultiPolygon, adding meaning beyond the generic 'object' type. However, it does not explain bbox coordinate order or units, leaving some ambiguity. Partial compensation.

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

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

The description clearly states the verb 'Screen' with a specific resource 'corrosion and shrink-swell pipe risk' and specifies the accepted input types (bbox or GeoJSON Polygon/MultiPolygon). It is distinct from all sibling tools, none of which mention pipe risk, so an agent can immediately identify its 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 gives clear context: it screens pipe risk for a bbox or polygon, implying when it should be used. However, it does not explicitly state alternatives or when not to use it, but since no sibling covers the same function, the context is sufficient.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, so the description does not need to cover safety. It adds value by specifying the exact content returned (metadata, provenance notes, linked resources), which goes beyond the annotations. No contradictions with annotations.

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

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

The description is a single sentence with no filler. It is front-loaded with the core action and resource, and every word contributes meaning. Perfectly concise for the tool's simplicity.

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

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

The tool is simple (one meaningful parameter) and has an output schema, so the description does not need to explain return values. However, given zero schema coverage, the description should have described the productId parameter to make the tool self-explanatory. It is functionally adequate but leaves the parameter undocumented.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the productId parameter. It does not mention the parameter at all, nor does it clarify that productId identifies the product whose metadata is retrieved. The description only references 'product metadata' without linking it to the parameter.

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

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

The description clearly states a specific action (Retrieve) and resource (LandIS product metadata), and further specifies the content: metadata, provenance notes, and linked resources. It distinguishes this tool from siblings like landis_catalog_list_products (which lists products) and landis_archive_get_item (which retrieves archive items) by focusing on metadata for a specific product.

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 metadata for a specific LandIS product is needed, but it does not explicitly contrast with alternative tools or state when not to use it. It lacks explicit routing guidance such as 'use this instead of landis_catalog_list_products when you have a product ID.'

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

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

The annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds minimal behavioral context beyond saying it 'summarizes,' and does not disclose what the summary contains or how the operation behaves. This is acceptable but not rich, given the annotations.

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

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

The description is a single sentence that is front-loaded and contains no filler. Every word contributes to identifying the tool's purpose and input scope.

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?

Although an output schema and read-only annotations exist, the description leaves essential invocation details unstated: whether bbox and geometry are alternatives, whether at least one is required, and what format values must take. The required-parameter count is 0, so an agent could try calling with neither input and get no guidance from the description.

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

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

Schema description coverage is 0%, and the description only mentions 'bbox or GeoJSON polygon' without explaining the bbox coordinate order, geometry structure, or how the parameters relate. With no parameter-level detail in the schema, the description should compensate but does not meaningfully do so.

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: 'Summarize NATMAP map units across a bbox or GeoJSON polygon.' This clearly identifies what the tool does. However, it does not explicitly differentiate it from similar siblings like landis_natmap_thematic_area_summary or landis_soilscapes_area_summary, so it is not a full 5.

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

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

The description implies that this tool is for area-based summaries via bbox or GeoJSON polygon, but it provides no explicit guidance on when to choose this tool over alternatives, no exclusions, and no note about whether bbox and geometry are mutually exclusive or one is required. An agent gets little help in deciding between this and related summary tools.

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

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

Annotations declare readOnlyHint and idempotentHint, covering the safety profile. The description adds no behavioral details beyond that, such as what happens for invalid coordinates, whether a map unit is always returned, or any rate limits. With annotations present, some credit is given, but the description offers zero additional context.

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

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

The description is a single efficient sentence that front-loads the action and resource. Every word is necessary; there is no fluff or repetition.

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

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

For a simple point lookup with an output schema present, the description is minimally adequate. But it omits any mention of edge cases like points outside coverage, the meaning of 'map unit', or how to select this tool over sibling lookups. The output schema covers return structure, so that gap is mitigated, but overall completeness is barely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It does specify that lat and lon are in WGS84, which adds coordinate system meaning beyond the plain 'number' type in the schema. However, it doesn't provide ranges, decimal degree format, or other constraints, leaving gaps that the schema does not fill.

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

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

The description clearly states the verb 'Get' and the resource 'NATMAP map unit' plus the input context 'at a WGS84 lat/lon'. This distinguishes it from area-oriented siblings like landis_natmap_area_summary by implying a point query, 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?

No guidance is provided on when to use this tool versus alternatives such as landis_natmap_area_summary or landis_soilscapes_point. The description does not mention any conditions, exclusions, or intended use cases beyond the basic function.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows the operation is safe and repeatable. The description's 'Summarize' aligns with read-only behavior but adds no further disclosure about side effects, permissions, or rate limits.

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

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

The description is a single, front-loaded sentence that communicates the core operation and inputs with no wasted words. It is appropriately sized for a simple tool.

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

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

The description leaves ambiguity about whether bbox or geometry must be provided, since the schema only requires productId. It also does not mention that the two spatial inputs are alternatives or what happens if neither is supplied. With an output schema present, return values are covered, but the input semantics are incomplete for correct invocation.

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

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

Schema description coverage is only 25%, so the description must compensate. It does add meaning by identifying bbox and geometry as spatial selectors ('across a bbox or GeoJSON polygon') and by naming geometry as a GeoJSON polygon, but it does not explain the relationship between bbox and geometry or their format beyond the schema.

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

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

The description uses a specific verb ('Summarize') and resource ('one NATMAP thematic product') and specifies the spatial scope ('across a bbox or GeoJSON polygon'). It clearly states what the tool does, though it does not explicitly differentiate from sibling tools like landis_natmap_area_summary.

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

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

The description provides no guidance on when to use this tool versus alternatives such as landis_natmap_area_summary or landis_natmap_point. There is no mention of prerequisites or scenarios where this tool is preferred.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the WGS84 coordinate requirement, which is useful. However, it does not disclose behavior such as whether results are sorted by distance, whether the limit applies before or after distance filtering, or what happens when no sites are found. With annotations covering safety, a 3 is appropriate.

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

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

One sentence, front-loaded with the verb and resource, and no filler. It is appropriately concise, though it could have used the available space to add parameter semantics without becoming verbose.

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

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

The tool has an output schema, so return values are documented elsewhere. The description is adequate for a simple nearest-point lookup, but given 0% schema description coverage and five parameters, it leaves the agent without guidance on limit/maxDistanceKm semantics and result ordering. It is minimally viable but not complete.

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

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

Schema description coverage is 0%, so the description must compensate for the five parameters. It only clarifies that lat/lon are a WGS84 point; it does not explain 'limit' or 'maxDistanceKm' semantics beyond their schema names. The description adds minimal value over the bare parameter names, leaving the agent to guess units and behavior for maxDistanceKm and the meaning of limit.

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 ('Find'), a resource ('LandIS NSI evidence sites'), and a spatial criterion ('nearest to a WGS84 point'). It is clear enough to distinguish from most siblings, though it does not explicitly name a sibling alternative like landis_nsi_within_area or landis_nsi_profile_summary.

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: provide a WGS84 point and get nearest sites. It does not explicitly state when to prefer this over landis_nsi_within_area (area-based) or landis_nsi_profile_summary (profile lookup), nor does it mention exclusions or prerequisites. The spatial 'nearest' phrasing gives some context, but no explicit routing guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the verb 'Get' is consistent with those, so there is no contradiction. The description adds no additional behavioral context such as rate limits, prerequisites, or return caveats, but the annotation coverage lowers the burden on 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?

A single ten-word sentence with no filler. It front-loads the operation and resource before the qualifying identifier, making the purpose immediately scannable.

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

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

For a simple read-only, idempotent lookup with an output schema and one required parameter, the description gives enough to call it correctly. The main gaps are the absence of sibling routing and the opaque phrase 'evidence summary', but those are secondary to successful invocation.

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

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

Schema has two parameters with no property descriptions, so the description carries some burden. It provides domain context for nsiId ('LandIS NSI site identifier') and implies a single integer ID, matching the schema minimum of 1; the const 'tool' parameter is not addressed, but its value is fixed and inferable from the schema.

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

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

The description uses the verb 'Get' with a clear resource ('evidence summary') and a precise selector ('one LandIS NSI site identifier'), so an agent knows this is an exact-ID lookup rather than a spatial or nearest-site search. It could be sharper by explaining what an 'evidence summary' contains, but it is not tautological or misleading.

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 explains when to choose this tool over landis_nsi_nearest_sites or landis_nsi_within_area. The phrase 'one ... site identifier' implies the caller should already have an nsiId, but no alternatives, prerequisites, or exclusion conditions 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?

The readOnlyHint and idempotentHint annotations already establish the safety profile, so the description only needs to add scope/behavior context. It does clarify that the tool filters by a bbox or GeoJSON polygon, but it does not disclose pagination behavior, whether bbox and geometry are mutually exclusive, or any coordinate system expectations.

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

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

The description is a single front-loaded sentence with no filler or redundant restating of the tool name. Every word contributes to the core meaning.

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

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

Given the output schema and read/idempotent annotations, the description covers the basic read operation. But with 0% schema coverage, five parameters, and no mention of whether bbox and geometry are alternatives, requiredness, or how offset works, the description leaves meaningful gaps that an agent must infer.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It adds minimal meaning for bbox and geometry ('within a bbox or GeoJSON polygon') but says nothing about limit, offset, the tool const, or the structure/CRS of the geometry object.

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

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

The description uses a specific verb ('List') with a specific resource ('LandIS NSI evidence sites') and a precise spatial scope ('within a bbox or GeoJSON polygon'). This clearly separates it from nearby siblings like landis_nsi_nearest_sites, which are point/proximity based.

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

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

Usage is implied by the phrase 'within a bbox or GeoJSON polygon', which tells the agent this is the area-based spatial query tool. However, there is no explicit when-to-use or when-not-to-use guidance, and no named alternatives such as landis_nsi_nearest_sites or landis_nsi_profile_summary.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that the tool accepts bbox or GeoJSON geometry, but does not disclose additional behavioral traits such as output structure, pagination, coordinate system expectations, or behavior when both bbox and geometry are provided. It provides marginal value beyond the annotations but not rich context.

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

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

The description is a single, concise sentence that front-loads the main action and resource. It contains no fluff and is immediately understandable. Every word earns its place.

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

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

Given that an output schema exists, the description doesn't need to explain return values. It covers the primary input options and the purpose. The schema note clarifies the anyOf constraint (bbox or geometry), and the description's 'or' aligns with that. It doesn't mention potential limitations or edge cases, but for a straightforward summary tool with read-only annotations, it is largely complete.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It mentions 'bbox' and 'GeoJSON Polygon/MultiPolygon', which map to the bbox and geometry parameters, and implies they are alternatives via 'or'. However, it does not specify the exact bbox format (e.g., [minLon, minLat, maxLon, maxLat]) or coordinate system, leaving room for ambiguity. It partially compensates for the schema gap but not fully.

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

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

The description clearly states the verb 'Summarize' and the specific resource 'LandIS Soilscapes coverage', and specifies the accepted input geometries (bbox or GeoJSON Polygon/MultiPolygon). This is sufficiently specific to distinguish it from sibling tools like landis_natmap_area_summary, which targets a different dataset, and landis_soilscapes_point, which is point-based.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. While the name and resource mention Soilscapes, it doesn't state when an agent should choose this over other area-summary tools (e.g., landis_natmap_area_summary, ons_geo_area_summary) or mention exclusions or alternatives. The usage context is only implied by the resource name.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds no behavioral detail beyond the return content; mentioning 'caveats' hints at the nature of the result but does not describe side effects, failures, or operational constraints. No contradiction with annotations.

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

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

A single front-loaded sentence with no filler. Every element—resource, output, input format—earns its place, and the essential 'WGS84 point' qualification is included.

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 point lookup with safe/idempotent annotations and an existing output schema, the description covers what the tool does and what input it expects. Minor gaps such as geographic coverage limitations or out-of-range coordinate handling are not stated, but they are not critical for invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the essential coordinate reference system (WGS84) and clarifies that lat/lon represent a single point. The self-descriptive parameter names plus this CRS context provide enough meaning for correct invocation, though the description could additionally state value ranges.

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 ('Return'), a specific resource ('LandIS Soilscapes class and caveats'), and a specific input modality ('WGS84 point'). This clearly distinguishes it from the sibling landis_soilscapes_area_summary, which is the area-based counterpart.

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 input condition 'for a WGS84 point' makes the use case clear and implies a single-point lookup as opposed to area summaries. However, it does not explicitly name alternatives or state when not to use the tool, leaving the routing decision partially to the agent.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds no behavioral context beyond the core actions; it does not mention response behavior, codelist name requirements, or any other operational traits.

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

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

The description is one short sentence with no filler. It front-loads the primary action and states the secondary action clearly, making it easy to scan.

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

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

Despite strong annotations and an output schema, the description is not complete enough for an agent to confidently choose between list and definition behavior or to understand the 'format' parameter. It is a minimal description for a tool with three parameters and zero schema-level parameter documentation.

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

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

Schema description coverage is 0%, yet the description does not explain the 'format' parameter or how 'codelist' selects a definition. It only hints that codelist relates to a definition, leaving parameter semantics largely to inference.

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 clear verb and resource: 'List NOMIS codelists' or 'return a codelist definition.' It identifies the domain sufficiently to distinguish it from sibling tools like nomis_datasets and nomis_concepts, though it does not explicitly name those 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?

There is no guidance about when to use the list mode versus the definition mode, nor any mention of how this tool relates to sibling tools such as nomis_concepts or nomis_query. Usage context is only implied by the resource name.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds a bit of behavioral context by indicating two modes—listing all concepts or returning one definition—but does not disclose any further behavior such as format effects, default behavior, or response characteristics.

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

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

The description is a single, efficient sentence with no filler words. It is front-loaded and readable, though its brevity sacrifices semantic detail that could have been included without bloating the text.

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

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

Given there are three optional parameters and no parameter descriptions, the description is too thin for an agent to know how to request a specific concept or select an output format. The presence of an output schema helps with return values, but the invocation semantics are left unspecified.

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

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

Schema description coverage is 0%, and the description provides no parameter information whatsoever. It does not mention the 'concept' parameter, the 'format' enum, or how to trigger a list versus a definition, so the agent must rely entirely on bare schema fields with no explanatory help.

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: 'List NOMIS concepts or return a concept definition.' It is clear enough to identify the tool's domain, but the dual-mode 'or' leaves ambiguity about when each behavior applies, and it does not explicitly distinguish it from siblings like nomis_datasets, nomis_codelists, or nomis_query.

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

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

No guidance is given about when to use this tool versus alternatives. The description implies two possible actions but gives no conditions, and it never mentions sibling tools or scenarios where another NOMIS tool would be more appropriate.

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

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

Annotations already declare the tool read-only and idempotent. The description adds a useful default behavior ('filtered and limited summary by default') but leaves the includeRaw requirement for full definitions to the schema, so an agent could slightly over-read 'return a dataset definition'.

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 front-loaded sentence with the primary verb and resource first. There is no filler, and both operating modes are conveyed efficiently.

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 minimally viable for a read-only listing/definition tool with an output schema and detailed input schema. However, it lacks guidance on when to select it over sibling NOMIS tools and does not mention output format options, leaving some selection burden on the agent.

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

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

With only 50% schema description coverage, the description adds some meaning by distinguishing list mode from definition mode and noting the default summary behavior. It does not explain format, limit, or the tool const, so it only partially compensates for schema gaps.

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

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

The description states a specific resource ('NOMIS datasets') and two clear operations: listing datasets or returning a dataset definition. It is clear enough to be separated from NOMIS codelists/concepts/query tools, though it does not explicitly name alternative 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?

Usage is implied: use this tool to list datasets or fetch a definition. There is no explicit when-to-use guidance versus nomis_query, nomis_codelists, or nomis_concepts, and no 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, covering safety and repeatability. However, the description adds no behavioral context beyond repeating the format enum from the schema. It does not disclose pagination, limits, error behavior, or what 'params' should contain.

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, terse sentence with no filler, which is efficient. However, its brevity is under-specification rather than conciseness – it omits essential details given the tool's complexity (4 params, nested object). It is structured to be quick to read but not informative enough.

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 a required dataset, a nested params object, and a format enum, the description is severely incomplete. It provides no instructions on building a valid query, what dataset identifiers look like, or how to structure the params object. Although an output schema exists, the input side is entirely 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 0% – no parameter descriptions exist in the schema. The description does not compensate: it only names the formats (already in schema) and fails to explain the 'dataset' parameter, the nested 'params' object, or the fixed 'tool' value. An agent has no idea what values to supply for these fields.

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

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

The description clearly states the verb 'Query' and the resource 'NOMIS datasets', explicitly mentioning the supported formats (JSON-stat or SDMX JSON). This distinguishes it from sibling tools like nomis_codelists, nomis_concepts, and nomis_datasets, which deal with dataset discovery rather than data retrieval.

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

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

There is no guidance on when to use this tool versus alternatives such as ons_data_query or nomis_datasets. The description only implies it queries NOMIS data, but does not explain selection criteria, prerequisites, or exclude cases. Sibling tools are not 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate safety. It adds the qualifier 'live' to 'dataset version,' which is useful context, but it does not describe what happens if the version is not live, what the output contains, or any other behavioral nuance. The description adds minimal value beyond the annotations.

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

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

The description is a single concise sentence, front-loaded with the action verb. It contains no unnecessary words or filler, making it efficient and easy to parse.

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?

While an output schema exists (so return format is covered), the description omits key context: the meaning of 'live,' the relationship between the parameters, and when to use this tool over similar siblings. For a tool with three required parameters and a crowded sibling space, the description leaves too much to inference.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not. It only hints at 'live dataset version' but does not define 'dataset,' 'edition,' or 'version.' With three required parameters and no parameter-level documentation, the description fails to help an agent understand what values to provide.

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

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

The description states a specific action ('List'), resource ('ONS dimensions'), and context ('for a live dataset version'). It clearly conveys what the tool does, but it does not explicitly differentiate from sibling tools like ons_data_dimensions or ons_codes_options, which may also deal with dimensions. Still, the purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or conditions that would route an agent to this tool over siblings like ons_data_dimensions or ons_codes_options. There is no implied usage context beyond the literal action.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the read-only nature is covered. The description adds 'List codes/options', which aligns with the annotations and clarifies the operation but does not disclose any additional behavioral aspects such as pagination, rate limits, or authentication. Since annotations carry the safety profile, the description adds minimal extra value, but there is no contradiction.

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

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

The description is a single, front-loaded sentence that directly states the action and target. It contains no unnecessary words, making it efficient. However, it is arguably too terse to be fully useful, but conciseness itself is well-executed.

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

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

Given the tool has 5 parameters (4 required) with no enum constraints and no schema descriptions, the one-line description is insufficient for an agent to understand the relationships between dataset, edition, version, and dimension, or what 'live dimension' means. The output schema exists, so return format is covered, but the request construction remains ambiguous. The description does not provide examples or additional context needed for correct invocation.

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

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

Schema description coverage is 0%, meaning the schema provides no parameter explanations. The description only hints at 'dimension' as the key parameter, but dataset, edition, and version are left completely unexplained. It fails to compensate for the lack of schema documentation, leaving the agent uncertain about how to construct valid requests.

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

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

The description clearly states the verb 'List' and the resource 'codes/options for a given ONS live dimension', which distinguishes it from sibling tools like ons_codes_list (likely for a different scope) and ons_data_dimensions (which lists dimensions, not codes within a dimension). However, it doesn't explicitly name any alternative or contrast with them, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives like ons_codes_list or ons_data_dimensions. It simply states what it does, leaving the agent to infer its appropriate context. No exclusions or explicit comparisons 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?

Annotations only provide openWorldHint: true, so the description carries most of the burden for behavioral disclosure. It adds that the operation targets 'live' observations and returns filterId, but it does not explain whether filters persist, expire, can be reused, or require any cleanup. No contradiction with annotations exists.

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

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

The description is genuinely concise and front-loads the core action, but it is under-specified for a tool with 7 parameters and no schema descriptions. It earns its two sentences, yet a few more sentences about usage and parameter roles would not be wasted.

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

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

Given the 7-parameter schema with zero coverage and an openWorldHint annotation, the description is not complete enough for reliable invocation. Even though an output schema exists, the agent lacks essential workflow context, such as what dataset/edition/version identify and how filterId is meant to be consumed afterward.

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

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

Schema description coverage is 0%, and the description provides no parameter-level meaning beyond the raw property names. With 7 parameters and no descriptions in either the schema or the tool description, the agent cannot determine valid formats, relationships between parameters, or how optional parameters affect the filter.

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 clear verb and resource: 'Create a filter for live ONS observations' and states the key result: 'Returns filterId.' This distinguishes the tool from siblings like ons_data_get_observation or ons_data_query, though it does not explicitly call out any sibling 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?

There is no guidance on when to use this tool versus alternatives such as ons_data_get_filter_output, ons_data_query, or ons_data_get_observation. The description implies a create-then-fetch workflow but never states it, leaving the agent to infer the proper sequencing.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, covering the safety profile. The description adds only the 'live API' context, implying fresh or uncached results, but does not disclose other behavioral traits such as how the optional dimension parameter affects the response.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to identifying the operation and resource.

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

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

For a simple read-only metadata tool, the annotations and existing output schema reduce the burden. However, the description still leaves gaps: it does not explain how to obtain valid dataset/edition/version values, nor how this tool fits into the broader ONS data workflow alongside sibling tools. This is adequate but not complete.

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

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

Schema description coverage is only 20%: only 'dimension' has a schema description. The tool description does not explain the required dataset, edition, and version parameters at all, nor how they scope the dimension list. With coverage this low, the description was expected to compensate and does not.

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

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

The description uses a specific verb ('List') and a precise resource ('ONS observation dimensions'), making the tool's job immediately clear. The name and wording distinguish it from sibling tools like ons_data_editions, ons_data_versions, and ons_data_get_observation without ambiguity.

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

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

The description gives no guidance on when to use this tool versus the many related ONS tools, such as ons_data_query, ons_data_get_observation, ons_data_editions, or ons_data_versions. Any usage context is only implied by the tool name, not stated.

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

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

Annotations already convey read-only, open-world, and idempotent behavior. The description adds 'live' as a scoping constraint (only live editions are returned), which is a useful behavioral detail beyond annotations. However, it does not disclose other behaviors like error handling or data freshness, so a mid-range score is appropriate.

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

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

The description is a single sentence with no fluff, front-loading the core action 'List live editions' before the scope. Every word earns its place, and the sentence is compact without being incomplete for its simple purpose.

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

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

Given the tool's simplicity and the presence of an output schema, the return shape is covered. However, the input parameter 'dataset' is left undefined, and 'live editions' could benefit from domain clarification. The description alone does not fully equip an agent to invoke the tool correctly without external knowledge.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints that a dataset is required ('for an ONS dataset') without specifying the expected format (ID, slug, name) or any constraints. This is insufficient for an agent to construct a valid parameter value with confidence.

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 ('List'), resource ('live editions'), and scope ('for an ONS dataset'), distinguishing it from the sibling tool ons_data_versions which deals with versions. The action is unambiguous and clearly separated from other data-related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like ons_data_versions or ons_data_query. It doesn't mention prerequisites, exclusions, or the specific situation where listing live editions is appropriate, leaving the agent to infer the usage.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds formats and a vague 'inline or resource delivery for larger outputs' hint, but does not explain what resource delivery returns or how size thresholds behave.

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

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

Two sentences with no filler. The core retrieval purpose is front-loaded, followed by the most relevant format and delivery details.

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

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

With an output schema, read-only annotations, and a single required parameter, the description is largely sufficient. It leaves delivery semantics and how filterId is obtained implicit, but these are inferable from the schema and sibling tool names.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions formats and inline/resource delivery, but filterId and inlineMaxBytes are left unexplainedchers, and there is no explicit mapping between the description and most parameters.

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

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

The description states a specific verb ('Retrieve') and a clear resource ('data for a previously created filter'), and it names the supported formats. This makes the tool's role distinct from sibling tools like ons_data_create_filter and ons_data_get_observation.

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

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

The phrase 'previously created filter' clearly situates the tool in a workflow: use it after creating a filter with ons_data_create_filter. It also mentions a delivery choice for larger outputs. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, covering the safety profile. The description adds only 'live' and 'single observation,' with no detail about failure modes, exact-match semantics, rate limits, or response behavior; 'live' also overlaps with openWorldHint.

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 single sentence is front-loaded, specific, and free of filler, making it easy to scan. However, its brevity is achieved by dropping important routing and parameter context, so it is concise but not optimally sized for the tool's complexity.

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

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

The description is too sparse to fully support invocation: an agent cannot determine how to fill required dataset/edition/version parameters or know when to prefer this over siblings like ons_data_query. The presence of an output schema mitigates the return-value gap but does not compensate for the missing parameter and routing context.

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

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

With 7 parameters and 0% schema description coverage, the description must compensate for the schema's silence. It names geography, measure, and time, but says nothing about dataset, edition, version, or value formats, leaving three of six required parameters completely unexplained.

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

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

The description uses a specific verb ('Fetch'), identifies the resource ('a single observation'), and names the source API ('live ONS API'). The word 'single' helps differentiate it from broader ONS query tools like ons_data_query, though it omits the required dataset/edition/version dimensions.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no sibling alternatives are named. The 'single observation' phrasing only implies an exact-lookup use case, leaving the agent to infer how this differs from ons_data_query or ons_data_create_filter.

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

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

Annotations already establish readOnly, openWorld, and idempotent behavior, so the bar is lower. The description adds that queries hit 'live' ONS observations, which implies current data and aligns with openWorld, but it does not disclose pagination limits, output size, or what auto-resolution means beyond the schema's term description. No contradiction.

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

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

One compact sentence front-loads the core action and then states the two invocation modes. Every word earns its place.

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

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

For a 12-parameter tool with no required params, the description gives the central mode distinction but not enough to assemble a correct query (how filters/measure/timeRange interact, what the output schema returns, or whether search term replaces dataset/edition/version entirely). Output schema exists and annotations help, so it is not critically incomplete, but it leaves meaningful gaps.

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

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

Schema coverage is 58%, so the description carries some but not full responsibility. It adds the useful distinction between live mode (dataset/edition/version) and search-term mode, but leaves measure, geography, filters structure, and timeRange semantics to the schema, and several params are undocumented.

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

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

Description names the verb 'Query' and resource 'live ONS observations', and identifies two entry modes: explicit dataset/edition/version or search term. It distinguishes from metadata siblings like ons_data_dimensions/editions/versions but does not contrast with the close sibling ons_data_get_observation.

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

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

The phrase 'dataset/edition/version or search term' conveys a clear context for using the tool in one of two modes, but it never names alternative tools or states when not to use it. An agent must infer the boundary against ons_data_get_observation, ons_search_query, or ons_data_create_filter.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, covering the basic safety profile. The description adds no behavioral context beyond 'list live versions' – it does not disclose what 'live' means (e.g., excluding archived or draft versions), pagination behavior, or any limits. With annotations present, the bar is lower, but the description still contributes little beyond the safety flags.

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

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

The description is a single, concise sentence that front-loads the core action and resource. There is no filler or redundancy – every word earns its place. It is optimally sized for the low complexity of 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?

For a simple list operation with an output schema present, the description is minimally adequate. It covers the purpose but omits any nuance about parameter semantics or what 'live versions' entails. Given the 0% schema coverage and lack of usage guidance, more context would be expected, though the output schema mitigates the need to describe return values.

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

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

Schema description coverage is 0%, so the description must explain the parameters, but it does not. It only mentions 'dataset' and 'edition' by name without adding format, constraints, or examples. The parameter names are self-explanatory to some degree, but the description fails to compensate for the missing schema documentation.

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

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

The description clearly states the action (list) and the resource (live versions for an ONS dataset edition). It is specific enough to distinguish from sibling tools like ons_data_editions (which lists editions) and ons_data_dimensions. However, it does not elaborate on what 'versions' means or how it differs from other list-type tools beyond the resource name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a dataset and edition), nor does it note when another tool like ons_data_editions or ons_data_dimensions would be more appropriate. Usage context is entirely implied by the tool name and parameters.

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

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

The annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context about data provenance, mentioning cached ONS geographies, compact inventory counts, and curated NOMIS follow-up datasets. However, it does not disclose fallback behavior such as exact vs best_fit resolution, error cases, or why a lookup might fail, though the annotation coverage softens this gap.

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

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

The description is a single sentence with no filler and front-loads the tool's purpose. It is efficient, though dense and jargon-heavy; a short structured list or a second clarifying sentence could have made the same content more legible without being 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?

Given the tool has 11 optional parameters, no required parameters, and zero schema-level parameter descriptions, the description is not complete enough for reliable invocation. It does not explain how inputs combine (e.g., postcode vs UPRN), which values targetLevel can take, what derivationMode exact vs best_fit means, or what happens when multiple identifiers are supplied. The presence of an output schema and annotations prevents a lower score, but significant operational context 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 0% across 11 parameters, so the description must compensate. It does connect some parameters at a high level: 'area code, postcode, or UPRN' maps to id, postcode, and uprn, while 'inventory counts' and 'NOMIS follow-up datasets' roughly map to includeInventory/inventoryResponseMode and includeProfileDatasets/profileCategories. But targetLevel, derivationMode, inventoryResponseMode semantics, profileCategories formats, and the boolean flags are left unexplained, leaving too much to inference.

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 ('Resolve'), a concrete resource ('compact OA/LSOA/MSOA/parish/ward/profile summary'), and accepted lookup inputs ('area code, postcode, or UPRN'). It does not explicitly contrast itself with sibling tools like ons_geo_by_postcode or admin_lookup_area_geometry, but the 'compact inventory counts' and 'curated NOMIS follow-up datasets' give it a reasonably distinct identity.

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 when-to-use guidance is given. The description does not state when this tool should be preferred over alternatives such as ons_geo_by_postcode, ons_geo_by_uprn, or landis_natmap_area_summary, nor does it mention any exclusions or prerequisites. The intended context is only weakly implied by the phrase 'from an area code, postcode, or UPRN'.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds genuine value by disclosing that results come from a cache (so may be stale rather than live) and that multiple geographies may be returned ('all cached geographies'). It does not disclose cache-miss behavior or staleness policy, but for a read-only tool with strong annotations, the added context is adequate though not rich.

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

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

A single 17-word sentence that front-loads the verb and resource, then attaches the parameter context. Every word earns its place and there is zero filler or repetition of schema content.

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

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

The output schema covers return structure, so the description doesn't need to explain results. For a read-only, idempotent lookup with an output schema, the core is covered. But an agent still lacks guidance on includeRaw's behavior, postcode formatting, and what happens when a postcode has no cached data — gaps that matter for correct first-time invocation. Adequate but with clear holes.

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