DaedalMap Administrative Boundaries (loc_id to polygon)

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

Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context beyond that: it is shape-only, fast, reports per-identity availability plus vintage, keeps historical geometry as the primary result, and requires no payment. These details help an agent predict behavior and side effects without contradicting the annotation.

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

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

The description is compact and front-loaded with the core purpose, then adds the most decision-relevant qualifications. Every sentence serves a purpose: what it does, what it returns, how historical geometry is treated, what it does not do, and when to use it.

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

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

Given the read-only annotation, 100% schema coverage, and the absence of an output schema, the description covers the essential return concept: whether geometry is reusable and its vintage. It also addresses cost, scope limits, and non-goals. It does not describe response structure or edge cases, but for a preflight tool the essentials are present.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters and the loc_id/loc_ids anyOf constraint. The description adds context about bounded lists and exact identity checking, but does not add significant parameter-level meaning beyond the schema, matching the baseline of 3.

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

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

The description clearly identifies a specific verb and resource: a fast shape-only preflight that reports geometry availability and vintage for exact loc_ids. It also distinguishes itself from actual retrieval operations by stating it is a preflight and does not resolve points or identity relationships.

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

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

The description gives explicit timing guidance: use before get_geometry or an export. It also clarifies non-intended uses by saying it does not resolve points or explain identity relationships, which implicitly separates it from tools like resolve_loc_id_scope and loc_id_info. It stops short of naming all alternatives explicitly, so it is not a perfect 5.

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

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

Annotations only mark readOnlyHint true, but the description adds valuable behavioral context: it returns results only 'when approved geometry exists', includes 'N-way successor context', and mentions that 'no payment required'—implying some external cost or authorization check. It does not contradict annotations and adds nuance beyond the simple read-only flag.

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

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

The description is four sentences, front-loaded with the purpose, then outputs, then usage context, then caveat and payment note. Every sentence adds distinct information with no filler, making it appropriately sized and structured.

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

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

Given the tool's complexity and lack of an output schema, the description covers key invocation context: when to use, what it returns, and a condition ('when approved geometry exists'). It does not explain what 'approved geometry' means or how to interpret 'N-way successor context', but it provides enough for an agent to select and call the tool appropriately.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'temporal validity' in outputs, which loosely ties to as_of parameters, but it does not add specific meaning to parameters like left_loc_id, include_successors, or batch_id. The schema itself already describes each parameter clearly.

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

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

The description clearly states it is a 'Detailed relationship tool for two geographic identities' and enumerates specific outputs: 'temporal validity, N-way successor context, topology, geodesic intersection area, and directional overlap shares'. This distinguishes it from siblings like get_geometry or loc_id_info, which focus on single identities.

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?

Explicit guidance is given: 'Use this after a compact point lookup when the caller asks whether two tiers/releases really contain or overlap one another' and 'Use resolve_reference first for names or outside identifiers.' This tells the agent when to use the tool and when to use an alternative, plus the caveat that 'a point-chain seam is not proof of strict parentage.'

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

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

The description discloses important behavioral traits beyond the readOnlyHint=false annotation: it is synchronous, has a size constraint and response-time budget on hosted service, and behaves differently for local loopback callers (no cap). These details inform the agent about operational limits and execution mode, adding substantial context beyond the annotation.

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

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

The description is three sentences, front-loaded with the core purpose, then adding constraints and alternative guidance. Every sentence earns its place; there is no redundancy or filler.

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

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

For a tool with 8 parameters, nested scope object, and no output schema, the description provides essential context: purpose, input modes, output formats, operational limits, and pointer to alternatives. It lacks explicit detail on scope object semantics and some optional parameters, but the schema provides partial descriptions, and the missing info may be non-critical for selection/invocation.

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

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

The description adds meaning beyond the schema by clarifying that loc_id, loc_ids, and scope are alternatives ('exact loc_ids or one strict scope') and by listing the output formats that map to the format enum. It also highlights the loc_ids limit. However, with only 38% schema coverage, it does not explain scope sub-properties, include_polygon, or output_name semantics, leaving some 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 begins with a specific verb ('Creates'), names the resource ('geometry export'), specifies input modes ('exact loc_ids or one strict scope'), and explicitly lists output formats ('GeoJSON, gzipped GeoJSON, or zipped GeoJSON'). This clearly distinguishes it from sibling tools like get_geometry or get_pack by emphasizing creation of an export rather than 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?

The description gives concrete guidance on when to use this tool versus alternatives: it states the hosted-service cap (250 loc_ids, 10-20 second response budget) and explicitly directs users to estimate_geometry_package or get_tool_help for determining the effective access lane. This is clear context for choosing this tool over siblings.

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

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

Annotations already declare readOnlyHint=true, and the description aligns by framing the operation as an estimate. It adds context beyond the annotation by enumerating what the estimate includes (loc_id count, shape/vintage availability, bytes, delivery mode, citation requirements, charge units) and by clarifying that it is not a canonical release bundle. This provides meaningful behavioral transparency without contradicting annotations.

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

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

The description is two sentences, front-loaded with the core action ('Dry-run estimate') and packed with specific output details. Every clause adds value, with no redundancy or filler.

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

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

The tool has 7 parameters and a nested object, but the schema handles parameter detail well. With no output schema, the description compensates by listing exactly what the estimate covers. It also clarifies the artifact boundary (not a canonical bundle). The only minor gap is not explicitly mentioning the three mutually exclusive input selectors (loc_id, loc_ids, scope), but the schema's anyOf provides that context.

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

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

Schema description coverage is 86%, so the schema already explains most parameters. The description adds no additional parameter details; it only names the tool's purpose. Baseline of 3 is appropriate because structured data carries the semantic load, and the description does not need to compensate.

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 ('estimate') and resource ('geometry export'), and clearly distinguishes this from actual creation by calling it a 'dry-run'. It also explicitly differentiates from 'canonical DaedalMap geometry release bundle', setting it apart from sibling tools like get_geometry and create_geometry_export.

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 'dry-run estimate' phrasing implies this tool is used before a real export, but the description does not explicitly state when to use it versus create_geometry_export or other alternatives. No exclusions or alternative tool names are provided, leaving usage to be inferred rather than directed.

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, so safety is covered. Description adds 'Free discovery' implying no cost/limits and 'live' implying freshness. However, no mention of pagination or output size limits, and no output schema to clarify return structure.

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?

Single sentence with key info front-loaded ('Free discovery'). No fluff.

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

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

For a zero-parameter read-only tool, the description provides sufficient context: what is returned and from where. Could mention if the list is exhaustive or paginated, but overall adequate.

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?

No parameters; schema coverage is trivially 100%. Description adds no param info needed.

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

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

Description clearly states verb (returns) and resource (list of live agent-ready data packs on DaedalMap). Distinguished from siblings: 'get_boundary' suggests boundaries, 'get_pack' suggests single pack, 'loc_id_info' suggests location data.

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 vs alternatives. 'Free discovery' hints at lightweight use, but lacks formal guidance. Adequate for a simple tool but could be more directive.

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 annotation already signals safety, and the description adds meaningful context: historical geometry is returned first, an evidenced successor is never auto-substituted, and no payment is required. It also discloses a key limitation—no hierarchy or crosswalk explanation—which helps agents avoid misuse. 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?

Six short sentences, each carrying distinct information: scope, return values, historical behavior, limitation/alternative, preference guidance, and cost. It is front-loaded with the most important retrieval statement and contains no filler.

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

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

Even though there is no output schema, the description clearly states what the tool returns, including metadata, vintage, centroid, bounding box, and optional GeoJSON polygon. It also covers behavior, cost, defaults, and routing to loc_id_info. An agent has enough context to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by advising when to request the full polygon versus bbox/centroid, and by clarifying that loc_ids may come from any level of a resolve_point chain. That goes beyond the schema's examples without duplicating them.

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

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

The description opens with a specific verb and resource ('Shape retrieval for exact loc_ids') and enumerates the return contents: metadata, vintage, centroid, bounding box, and optional GeoJSON polygon. It explicitly distinguishes itself from loc_id_info by stating it does not explain hierarchy or crosswalks. An agent can tell this tool apart from its siblings without opening the schema.

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

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

It gives actionable direction to prefer bbox/centroid unless exact rendering or clipping requires the polygon, which effectively guides use of include_polygon. It names loc_id_info as the explicit alternative for hierarchy/crosswalk questions. The resolve_point chain scope also clarifies when this tool applies.

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 read-only annotation is complemented by the description's clarification that only completed inline jobs are retrievable, and that queued jobs or artifact links are not yet available. This adds practical expectations for callers.

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

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

Two sentences deliver purpose and limitations clearly, with no wasted words. The first sentence is immediately actionable, and the second provides necessary context without bloat.

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

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

Although no output schema exists, the description is sufficient for a simple retrieval operation, covering what is retrieved and noting what is not available. It does not describe the response structure or error behavior, but these are less critical given the tool's simplicity.

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

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

The schema already fully describes both job_id and request_id, so the description adds no new parameter semantics. It only restates job_id as a lookup key, which is redundant with the schema's 100% coverage.

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

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

The description clearly states the tool's action: retrieving a completed geometry export or conversion job by job_id. Its focus on job retrieval distinguishes it from sibling tools that create runs or estimate packages. The phrase 'completed bounded v0' adds precise scope.

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

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

The description implies this tool is for fetching jobs after creation, with a note that only inline completed jobs are supported under the current contract. It does not explicitly say 'use this after create_geometry_export' or list when not to use it, leaving the guidance implicit.

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

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

With readOnlyHint=true already provided, the description adds value by enumerating the exact types of information returned (metadata, coverage, freshness, canonical tool guidance, first-query examples). It reinforces the non-destructive nature and gives a concrete sense of the output without contradicting the annotation.

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

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

The description is two sentences, front-loaded with the tool's classification ('Free discovery') and the primary action ('Returns...'). Every phrase contributes meaning, and the usage instruction is placed at the end without redundancy. No filler.

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

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

For a simple read-only tool with one parameter and no output schema, the description fully covers what the agent needs to know: what it returns (detailed list), why to call it (before querying a new pack), and that it's free/safe. The readOnlyHint annotation handles safety, and the input schema covers the parameter. Nothing essential is missing.

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

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

Schema description coverage is 100% and already specifies pack_id as 'Pack identifier from get_catalog.' The description only adds a trivial confirmation ('for one pack') that doesn't significantly enhance understanding of the parameter beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Returns') and resource ('detailed metadata, coverage, freshness, preferred canonical tool guidance, and first-query examples') for a single pack. It clearly distinguishes itself from siblings like get_catalog (which lists packs) and get_geometry (which fetches geometry) by emphasizing 'one pack' and 'discovery'.

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

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

The instruction 'Call this before querying a new pack' provides explicit when-to-use context and the rationale ('see time shape, coverage limits, and the paste-ready first query'). It does not mention exclusions or name alternatives directly, but the guidance is clear enough for an agent to recognize the appropriate scenario.

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 extensively discloses behavioral traits beyond the readOnlyHint annotation, including 'what it refuses', 'effective access limits', 'provenance fields', and the 'natural-language-to-strict-JSON interaction contract'. This provides substantial insight into the tool's behavior and outputs.

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

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

The description is compact—two sentences—with the primary purpose front-loaded. The list of returned content is informative and each clause earns its place without redundancy.

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

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

Given the single parameter, no output schema, and readOnly annotation, the description provides a thorough overview of what the tool does, what it returns, and the recommended workflow, making it self-sufficient for an unfamiliar caller.

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

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

The input schema fully describes 'tool_name' as 'Exact tool name from tools/list', and the description reinforces this by saying 'Use tools/list to discover names'. With 100% schema coverage, the description adds minimal new semantic value for the parameter, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as a help/metadata provider for a single tool, listing specific returned content categories (when to use, refusals, example, access limits, outputs, provenance, next calls, contract). It contrasts with the sibling geometry tools by being a meta-guidance resource.

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

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

The description gives explicit usage context: 'Use tools/list to discover names, then call this before an unfamiliar tool.' This establishes a clear workflow and when to invoke it. It does not explicitly mention exclusions or alternatives, but the purpose is unambiguous.

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 adds rich behavioral context beyond the readOnlyHint annotation. It discloses that historical records are returned as requested, that supersession is never fetched or substituted automatically, and that hierarchy never invents parent edges across mixed releases. It also notes that no payment is required, which is useful operational 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 front-loaded with the core purpose and invocation pattern, then systematically covers behavior, parameters, and alternatives. Every sentence contributes value, and the differentiation from sibling tools is integrated efficiently without excessive length.

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 having no output schema, the description lists the key return categories: metadata, parentage, shape status, vintage/lifecycle fields, and child counts. It also explains the two input modes, discusses historical and supersession behavior, and points to the correct alternatives. Given the tool's complexity, this is a complete and well-rounded definition.

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

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

The input schema already documents all 11 parameters at 100% coverage, so the baseline is 3. The description adds meaningful semantic context by explaining the purpose of include_hierarchy as 'strict same-release ancestor chain' and include_references as 'external or side-chain crosswalks,' and by clarifying that loc_ids can come from a resolve_point stack.

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 this is the drill-down tool for loc_ids, enumerating the specific things it retrieves: metadata, strict stored parentage, shape status, vintage/lifecycle fields, and child counts. It also distinguishes itself from related tools such as get_geometry and compare_geographies, making its purpose unambiguous.

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

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

The description explicitly says when to use this tool versus alternatives: 'For exact polygons use get_geometry, and for overlap or successor analysis use compare_geographies.' It also explains the intended workflow with resolve_point, noting that this tool is where detailed chain explanation belongs while resolve_point stays compact.

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 description adds crucial constraints: strict hierarchy, no bridging release seams, no natural-language decoding. This goes beyond safe-read tagging to define traversal semantics.

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?

Four sentences, front-loaded with a clear one-line summary, and every sentence earns its place: purpose, disambiguation, use case, and exclusion. No fluff.

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

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

For a moderately complex tool with 8 params and no output schema, the description covers traversal logic, exclusions, and a concrete use case. However, it does not specify what a successful response contains (e.g., loc_id rows vs. counts), which the schema hints at but doesn't fully clarify. Slightly short of complete.

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

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

Schema coverage is 88% and describes most parameters (parent_loc_id, admin_level, bbox, limit, offset, count_only). The description only reinforces core params but doesn't add syntax or format details beyond schema, so baseline 3 is appropriate.

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

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

States a specific verb+resource: 'Strict hierarchy traversal' of loc_ids, returning descendants from a 'coherent parent chain.' Excludes the alternative 'mixed-vintage latest-per-depth point resolver,' clearly distinguishing from siblings.

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

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

Explicitly states when to use ('before shape exports such as every county in a selected parent scope') and when not to ('must not bridge release seams'), also naming the alternative resolver.

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