ikeytz Einsatzgebiet-Karten

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'DOES NOT send mail' while adding real context beyond the annotation: the exact content yielded (two email addresses, with one surfaced as mapsHref). This is genuinely useful because the compose_* verb could otherwise imply sending. 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?

Roughly 20 words, dense and front-loaded: resource, usage, exclusion, next steps in a fixed WHAT/USE/DOES NOT/NEXT pattern. Every clause earns its place. The telegraphic style trades a little readability for compactness but remains 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 no-argument compose helper with an output schema present, the description covers all call-relevant facts: the exact addresses, when to use it, that it does not transmit mail, and suggested next calls. Return-shape details are already owned by the output schema, so nothing needed to select or invoke it correctly 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?

With zero parameters, the input schema is already exhaustive, so baseline 4 applies. 'Call with {}' restates the no-arg invocation and confirms no hidden arguments exist, which is all the description needs to add. Schema coverage at 100% leaves no param semantics 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 'WHAT:' line identifies the exact resources produced — mailto:info@ikeytz.com and the mapsEmail variant info@maps.ikeytz.com — and 'USE for email CTAs' ties it to a concrete purpose. The name compose_mailto alongside compose_tel_landline/compose_tel_mobile/compose_whatsapp siblings pins down the email channel. It lacks an explicit behavioral verb like 'returns' or 'builds', but an agent can infer the tool supplies email contact 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?

'USE for email CTAs' explicitly states the intended scenario, and 'DOES NOT send mail' is a clear exclusion that prevents misuse when actual sending is needed. It doesn't name alternatives like compose_whatsapp, but sibling names plus the CTA context make the boundary legible. 'NEXT: get_contact, list_footer' adds useful follow-up flow guidance.

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

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

Annotations already declare readOnlyHint=true, so the read-only behavior is covered. The description adds the return shape ('RETURNS href + display') and the no-argument call style, but does not add richer behavioral context such as what the link is intended for beyond a CTA.

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 WHAT, RETURNS, USE, and NEXT. Every segment delivers a distinct piece of information and there is 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 zero-argument read-only tool with an output schema, the description covers the purpose, usage context, return value, and related sibling. Nothing essential is missing for an agent to select and invoke this tool correctly.

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

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

The tool has zero parameters and the schema already documents this with 100% coverage. The description's 'Call with {}' reinforces that no arguments are needed, which is sufficient given there are no meaningful parameter semantics to define.

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 'WHAT: tel: href for the public landline,' which names a specific resource and format of output. It also signals the sibling distinction by saying 'public landline' and points to compose_tel_mobile as the next tool.

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

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

The description gives clear context by stating 'USE as secondary call CTA' and alludes to the mobile alternative with 'NEXT: compose_tel_mobile.' It does not explicitly state when not to use it, but the landline versus mobile distinction provides workable 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?

The annotations already declare readOnlyHint=true. The description adds valuable non-obvious behavior: 'DOES NOT place the call' and 'RETURNS href + display', clarifying that this only composes a link and has no dialing side effects. This goes beyond the annotation without contradicting it.

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 uses a compact, labeled format (WHAT, RETURNS, USE, DOES NOT, NEXT) that front-loads the core purpose and keeps each sentence meaningful. There is no filler or redundant restating of the schema.

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-argument, read-only tool with an output schema, this description covers everything needed: what it returns, how to use it, what it does not do, and where to go next. The output schema already defines the return value structure, so no additional return documentation is needed.

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

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

The tool has zero parameters and the schema already documents this with 100% coverage, including 'Call with {}'. The description reinforces the empty-call convention. With no parameters, the baseline of 4 is appropriate; there is nothing more to explain.

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 the exact deliverable ('tel: href for the public mobile number'), the returned data ('href + display'), and its role as the primary call CTA. It also names distinct siblings via the NEXT line, making it easy to differentiate from compose_tel_landline and list_whatsapp_options.

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 explicit context ('USE as the primary call CTA') and suggests follow-up tools with NEXT, which implies the caller should decide between mobile, landline, and WhatsApp. It does not explicitly state when NOT to use this tool, but the placement and naming of siblings provide adequate 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?

The annotation readOnlyHint=true already establishes the safety profile, and the description adds meaningful behavior beyond it: 'Link only — no form' clarifies the tool produces a link and performs no sending or UI rendering. This is consistent with the readOnlyHint annotation, so no contradiction 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?

Five short labeled clauses (WHAT, option, Link only, USE, NEXT) each carry distinct information: core purpose, parameter, behavioral caveat, use case, and follow-up routing. There is no filler, and the most essential facts are front-loaded. The label-shorthand style is slightly unconventional but economical.

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

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

For a simple tool with one optional parameter, a readOnlyHint, and an output schema, the description covers purpose, parameter semantics, behavioral scope, and use case. The only notable gap is that it never states the default behavior when option is omitted, though the schema's 'Optional' flag partially mitigates this.

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

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

Schema description coverage is 100%, and the description's parameter text (zugefallen|abgeschlossen|zylinder|beratung, or list_whatsapp_options ids) nearly duplicates the schema's own description. Per the baseline rule for high coverage, 3 is appropriate — the description adds no real semantic value beyond the structured 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 identifies the resource ('wa.me link') and the action ('open WhatsApp with a prefab'), and its channel-specific wording distinguishes it from the compose_* siblings (compose_mailto, compose_tel_landline, compose_tel_mobile). It loses a point because 'WHAT: wa.me link' is a noun phrase rather than a clean verb+resource statement, leaving the purpose to be inferred from telegraphic shorthand.

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

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

'USE to open WhatsApp with a prefab' explicitly states the intended use case, and 'NEXT: compose_mailto, get_contact' routes the agent to related follow-up tools. However, there are no explicit exclusion rules telling the agent when NOT to use this tool versus those alternatives, so it stops short of the full when/when-not guidance a 5 requires.

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 declare readOnlyHint=true, so the description adds valuable behavioral context: the result is air distance, not driving distance; no routing occurs; and the response contains from, office, and distance_km. This goes well beyond the safety 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, keyword-labeled, and front-loaded with the core behavior. Every sentence earns its place: input types, output fields, usage intent, routing limitation, and suggested next tools.

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?

Combined with a fully documented schema, an output schema, and a read-only annotation, this description covers inputs, outputs, limitations, and alternatives. An agent has everything needed to call it correctly and to avoid misusing it for driving-time calculations.

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 each parameter precisely. The description groups them into 'Gebiet (slug|plz|name) or lat/lng/icbm' but does not add new meaning beyond that grouping.

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: computes air distance in km from a Gebiet or lat/lng/icbm to the Gewerbesitz. It also distinguishes itself as a rough-proximity tool rather than a routing tool, separating it from sibling geo 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?

'USE for rough proximity — not driving time' explicitly states when to use the tool and what it is not for. 'DOES NOT route via OSRM' and 'NEXT: get_geo_office, find_by_geo' give the agent an actionable reason to choose this tool or move to a sibling.

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, the description does not need to restate safety, and it adds 'multi-match by q/name/slug' and 'same inputs and outputs' as behavioral context. It stays consistent with the annotation and contributes useful matching behavior.

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

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

The WHAT/USE/NEXT structure is compact, front-loaded, and every sentence provides a distinct piece of information. No filler or repetition.

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

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

Given the output schema, readOnly annotation, and the explicit alias to find_by_gebiet, the remaining context (what find_by_gebiet returns, how matches are ordered) is delegated to the sibling and output schema. That is sufficient for selecting and invoking the tool, though slightly less self-contained.

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 q, name, and slug thoroughly. The description merely lists the same parameter names without adding new meaning, so the baseline 3 applies.

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

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

The description identifies the tool as an alias of find_by_gebiet and specifies the query dimensions (q/name/slug) and multi-match behavior, so an agent can tell what it does. It does not fully define 'area' or the result semantics on its own, leaning on the sibling's definition, which prevents 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?

Explicitly states when to choose this tool: when the agent prefers 'area' naming, and points to next tools. It does not explicitly state when not to use it or contrast with other find_by_* siblings beyond the alias relation.

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 communicates safety, so the description adds useful behavior beyond it: substring matching, multi-match results, umlaut tolerance, and no necessity for an exact slug. It discloses that the tool returns all matching point cards rather than a single exact hit. This exceeds the annotation's minimal coverage.

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

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

The description is tightly structured with concise labels (WHAT, RETURNS, USE, DOES NOT, NEXT) and front-loads the core purpose. Every sentence contributes value, and there is no redundant repetition of schema content. It is both compact and highly 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?

Given the output schema, readOnly annotation, and straightforward parameter list, the description covers the tool's purpose, usage, behavioral expectations, and next steps. Minor gaps like behavior when no parameters are supplied or direct alternatives among the find_by_* siblings are not addressed, but these are secondary for a fuzzy search tool.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds meaningful semantics by framing all three parameters as fuzzy, substring-based search inputs and emphasizing multi-match behavior. It clarifies that exact slug matching is not required, which is not directly stated in the schema. This provides additional operational meaning beyond the field-level descriptions.

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

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

The description clearly identifies a specific resource (Gebiete) and operation (multi-match search by q, name, or slug), stating it returns all matching point cards. It distinguishes itself by emphasizing substring matching, umlaut tolerance, and the lack of an exact slug requirement. This is specific enough to tell it apart from the many sibling find_by_* 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 gives a clear usage context ('USE for fuzzy place names') and asserts a key exclusion ('DOES NOT require exact slug'). It also suggests follow-up tools (get_service_area, get_grenze) via 'NEXT'. It does not explicitly contrast with find_by_plz or find_by_keyword, but it provides sufficient contextual guidance for when to choose this tool.

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

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

Beyond the readOnlyHint annotation, the description discloses key edge behavior: '(0,0) and far points → ok=false outside_service_area' and the return field 'distance_km'. It also clarifies ordering semantics ('nearest N') and that routing is not supported.

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 labeled sections ('WHAT', 'RETURNS', 'USE', 'DOES NOT', 'NEXT'), making it easy to scan. Every sentence adds value, and there is no redundant filler.

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

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

Given the read-only annotation, complete schema descriptions, and presence of an output schema, the description covers the essential behavior, parameter interactions, edge cases, and usage guidance. No critical operational information appears missing for an agent 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?

The schema already covers 100% of parameters in detail. The description adds interaction semantics by explaining 'Optional radius_km; else nearest N (limit, default 5)' and linking coordinates to the outside_service_area edge case, which goes beyond the schema baseline.

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

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

The description clearly states the action ('Rank Einsatzgebiete by lat/lng (or icbm)') and the resource being queried. The 'RETURNS items with distance_km' statement makes the purpose concrete and distinguishes it from sibling tools like find_by_plz or find_by_area.

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 explicitly says 'USE for "near this coordinate"' and 'DOES NOT route or drive-time', which tells the agent when to choose this tool and what it will not do. The 'NEXT:' list also points to related tools, providing helpful routing context.

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

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

Beyond the readOnlyHint annotation, the description discloses the special (0,0) → outside_service_area behavior and the ranking equivalence with find_by_geo. This gives agents useful behavioral context for interpreting results that annotations alone do not provide.

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 well-structured with 'WHAT:', 'USE when', and 'NEXT:' labels. Every sentence earns its place, front-loading the core action before edge cases and suggested follow-ups.

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 a fully documented schema and an output schema, the description covers the key usage context, special-case behavior, and next steps. Its only minor gap is not disambiguating from find_by_icbm when raw ICBM coordinates are pasted, but it is otherwise complete for the stated Maps pin scenario.

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 description is not burdened with documenting parameters. It does restate the q/icbm/lat/lng alternatives in prose, but adds minimal new meaning beyond the schema's own parameter descriptions.

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

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

The description states a specific verb and resource: 'Paste Google Maps / ICBM coordinates' yields 'nearest ikeytz Gebiete'. It also distinguishes itself by noting the same ranking as find_by_geo and the (0,0) edge case, making it clear which coordinate-paste scenario this tool handles.

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 'USE when the user pastes a Maps pin', providing a clear trigger condition. It does not, however, explicitly state when not to use it or compare to closely related siblings like find_by_icbm or find_by_geo beyond the ranking note.

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, so the description does not need to cover safety. It adds some behavioral context beyond annotations, such as preferring the ICBM string when both forms are supplied and the '(0,0) → outside_service_area' special case, though '(0,0)' is also present in the schema. The behavior is not richly described, but it is adequate for a read-only lookup tool.

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 skimmable, using labeled fragments (WHAT/USE/NEXT) that front-load the core purpose and trigger. It earns its length, though 'Same as find_by_geo' is not fully self-contained and shifts some burden onto the sibling's definition.

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 five optional parameters, full schema coverage, an output schema, and a read-only annotation, the description covers the essential selection trigger and special edge case. It could say more about what the tool returns or which sibling to use for plain lat/lng, but the provided information is sufficient for correct tool selection in most cases.

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 five parameters. The description repeats the parameter list and adds the priority of ICBM over lat/lng, but provides no substantially new meaning beyond what the schema already conveys. Baseline of 3 is appropriate.

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

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

The description identifies a specific find operation with a clear input preference (ICBM 'lat, lng') and distinguishes it from the sibling find_by_geo by saying it is 'same as find_by_geo but prefers icbm string.' It does not state what entity is being found, so it relies partly on the sibling's definition, but the name and trigger make the purpose reasonably 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 gives an explicit trigger: 'USE when the user pastes ICBM metadata.' This is clear, practical guidance for selection. It does not explicitly say when not to use it or fully contrast it with find_by_geo, but the reference to find_by_geo and the input preference imply the boundary.

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 declares the read-only safety profile, so the bar is lower here. The description adds meaningful behavioral context: it targets maps llms-keywords.txt, returns keyword/url rows, applies a clamped limit, and explicitly does not search www keywords. These are non-obvious behaviors beyond annotation defaults.

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 tightly structured with WHAT/RETURNS/USE/DOES NOT/NEXT, and every phrase earns its place. It is short, scannable, and front-loads the most important facts before the follow-up guidance. There is no filler or repetition of schema details.

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

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

The tool has an output schema, so return structure is covered elsewhere. The description covers the data source, required parameter, result shape, intended use case, non-www exclusion, and a clear next step. For a search tool with one truly required parameter, the definition is complete enough for an agent to select and invoke it correctly.

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

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

The schema description coverage is 100%, so the baseline is 3. The description confirms that q is required and that results are clamped, but it does not add meaning beyond what the rich schema already provides for q, limit, and locale. The schema itself carries the parameter documentation burden, so no penalty is warranted, but there is also no extra semantic lift.

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

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

The description uses a specific verb ('Search') plus a precise resource ('maps llms-keywords.txt (keyword → maps URL)'), immediately making the tool's job unambiguous. It also states the 'DOES NOT search www keywords' exclusion, which distinguishes it from a likely point of confusion. The format clearly communicates the verb, resource, and 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 gives an explicit use case ('USE for SEO/keyword → Gebiet page') and a clear exclusion ('DOES NOT search www keywords'). It also provides a follow-up workflow ('NEXT: get_service_area / get_embed_map'), but it does not explicitly name alternative sibling tools like find_by_geo or find_by_gebiet for when this tool is not appropriate. Still, the when-to-use guidance is concrete and useful.

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 annotation only declares readOnlyHint=true; the description adds meaningful behavioral details beyond that, such as returning all matching entries rather than just the first, and the response shape 'items[] point cards + count.' This enriches the agent's understanding of what will happen.

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 well-structured with WHAT, RETURNS, USE, and NEXT labels. Every sentence adds a distinct piece of information, and the most important scoping detail is front-loaded.

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 lookup with an existing output schema and full schema coverage, this description covers the essential points: what it returns, when to use it, how to specify the postcode, and what to do next. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already documents plz and q well. The description's 'plz required (or q as PLZ)' restates the schema's alias relationship without adding new format, constraints, or interaction details, so it stays at the baseline.

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

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

The description clearly states that the tool returns all Einsatzgebiete matching a PLZ, with the explicit caveat 'not only the first' to distinguish it from tools that might return a single result. It also names the next tool in the workflow, get_service_area(slug), for drilling into one card.

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 an explicit usage condition: 'USE when several Stadtteile share a postcode.' It also provides an alternative path with 'NEXT: get_service_area(slug) for one card,' which tells the agent when to move on to a different tool.

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

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

Annotations provide readOnlyHint=true, so the safety profile is already covered. The description adds useful behavioral context beyond that: it searches a specific local file format rather than live HTML, and returns path/url/snippet items, giving the agent a clear expectation of scope and output granularity.

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?

Each label (WHAT, RETURNS, USE, DOES NOT, NEXT) carries distinct information with no wasted words. The description is front-loaded with the core action and purpose, then covers boundaries and alternatives 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?

For a read-only search tool with an output schema and well-documented parameters, the description supplies the missing context: the data source scope, the intended use case, the no-scraping boundary, and the follow-up tool. An agent has enough to select and invoke it correctly among many find_by_* siblings.

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 q, url, path, slug, and limit. The description adds a compact grouping of the searchable fields but no additional parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Search maps llms-serp.txt blocks') plus the searchable fields and the returned item shape. The description clearly differentiates from siblings by naming get_serp_snippet for full-block retrieval and noting it does not scrape live HTML.

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 says when to use it ('USE for title/H1/description SERP cards on maps'), what it does not do ('DOES NOT scrape live HTML'), and names the next appropriate tool ('get_serp_snippet for one full block'). This gives an agent actionable routing guidance beyond the schema.

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, so the description does not need to restate safety. It adds meaningful behavioral context: the tool is scoped to maps.ikeytz.com, returns the same core card as site_overview, and excludes the www about body. This goes beyond the annotation without contradicting it.

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 WHAT/USE/DOES NOT/NEXT structure front-loads the key facts in a compact, scannable format. Every sentence contributes distinct information, and there is no filler or repetition of the schema.

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

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

For a single-optional-parameter read-only tool with schema coverage at 100% and an output schema present, the description is complete. It covers scope, exclusions, related tools, and the intended use case, leaving no critical gap for the agent to call it correctly.

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

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

Schema coverage is 100%, and the schema already documents locale fully: enum de, default de, and explanation that maps is German-only and locale is not a www switch. The description adds little parameter-level meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly identifies the resource ('About maps.ikeytz.com'), the intended query ('what is this host'), and the exact scope ('52 maps, not www Über-uns corpus'). It also explicitly states what the tool does NOT return, which sharply distinguishes it from related tools like site_overview and www about pages.

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 an explicit USE case ('what is this host'), an explicit exclusion ('DOES NOT return www about body'), and names related/next tools. It also routes the agent to list_locales when a www multi-locale switch is needed, so the agent knows when to pick a different tool.

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

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

Beyond the readOnlyHint annotation, the description discloses that the tool returns a pointer/html+note rather than the corpus, and that the body text is deliberately not returned. The 'maps' wording is unclear, but the core behavioral limitation is stated directly.

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

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

The description is short and front-loaded with 'WHAT: www pointer only,' which is good. However, the compressed fragments and the unclear 'maps returns html + note' clause make it feel cryptic rather than cleanly concise.

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

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

Given that this is a zero-argument pointer tool with an output schema and a read-only annotation, the description covers the essential context: the URL, the purpose, the non-return of body text, and the alternative tool for the full document. The ambiguity around 'maps' prevents a perfect score.

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

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

The tool has zero parameters and the schema already documents that no arguments are needed, so the baseline for this dimension is 4. The description adds no parameter-specific meaning, but none is 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?

The description clearly identifies the tool as a www pointer to the AGB page at www.ikeytz.com/agb and explicitly states it does not return the AGB body text. The 'maps returns html + note, not the corpus' clause is ambiguous and slightly muddles an otherwise clear 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?

It explicitly says to use this tool for opening or handing off to the www MCP, and names get_legal(doc=agb) as the next step for the actual document body. This gives the agent a clear when-to-use and when-not-to-use boundary.

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

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

Beyond the readOnlyHint annotation, the description discloses a real behavioral trait: it reads the maps file 'when present; else www pointer for the path'. It also clarifies that the return value is text. The 'www pointer' phrase is vague, but there is no annotation contradiction and the read-only nature is accurately represented.

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 labeled WHAT / RETURNS / USE / NEXT structure is compact, front-loaded, and mostly free of filler. The telegraphic style and the ambiguous 'www pointer' phrase keep it from a perfect 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 read-only tool with no required parameters, an output schema, and 100% schema coverage, the description covers the target resource, fallback behavior, return type, and intended use case. The main gaps are the unexplained 'www pointer' and the absence of explicit sibling selection guidance.

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

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

Schema coverage is 100%, and the input schema already explains path, slug, and locale in detail. The description only adds 'path or slug', which is a marginal restatement of the schema. Baseline 3 applies because the schema does the heavy lifting.

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 opens with the verb 'Read' and a precise resource, 'maps /ai-pages/de/{slug}.txt', and distinguishes the tool by calling it 'maps AI pages' with 'agent-ready Gebiet prose'. It does not fully contrast with sibling tools like get_ai_txt or get_page_summary, so it stops 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?

'USE for agent-ready Gebiet prose' gives a clear intended context, and 'NEXT: get_service_area, get_lage' suggests related follow-ups. However, the description does not state when not to use this tool or name alternatives for the same task; the locale-based exclusion lives in the schema rather than the tool description.

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

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

The description adds that the tool maps /.well-known/ai.txt 1:1, clarifying it is a direct read of a static resource. The readOnlyHint annotation already covers the safe-read behavior, and no contradictions are present. However, it does not disclose error handling, encoding, or content shape beyond what the schema and output schema already imply.

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 uses clear WHAT/USE/NEXT labels to front-load the key information. Every segment earns its place, though the 'ai-train=no' parenthetical is somewhat cryptic and could be clearer.

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 discovery-file tool with fully documented parameters and an output schema, the description provides enough context: what it aliases, what it maps, when to use it, and where to go next. The only minor gap is that the exact meaning of 'ai-train=no' is left unexplained.

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

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

Schema description coverage is 100%, so the limit and offset parameters are fully documented in the schema. The description itself adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

The description clearly states this tool is an alias for get_discovery(which=ai-txt) and maps /.well-known/ai.txt 1:1, making the resource and operation explicit. It also distinguishes itself from nearby siblings like get_discovery and get_llms_txt by naming the alias target and the next tool.

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

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

The description explicitly says 'USE for crawl/train policy', giving a concrete scenario for when to invoke this tool. It also points to get_llms_txt as the next tool, which implies an alternative, though it does not fully explain the trade-off between the two.

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, the safety profile is already covered by annotations. The description adds minor behavioral context by calling it a 'www pointer only' and mentioning that 'maps returns html to that path,' but these phrases are cryptic and do not clearly explain what the agent should expect beyond the output schema.

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

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

The description is short and front-loaded with WHAT/NEXT labels, but the 'NEXT: www get_auswahl_item' line is redundant and the sentence 'maps returns html to that path' is unclear. It is concise but not cleanly structured for an AI agent.

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

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

The tool is simple with only two parameters, an output schema, and a read-only annotation, so the description does not need to explain return values. However, the cryptic phrasing and lack of routing guidance leave enough gaps that the description is only minimally 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 100%, so the description does not need to explain the parameters. It only repeats that slug is required, which the schema already states, and adds no meaningful semantics 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 states a specific verb and resource: it retrieves one Auswahl item at the www path /auswahl/{slug}, and notes that slug is required. This distinguishes it from list_auswahl, which would return multiple items, even though the phrase 'www pointer only' and the trailing 'NEXT: www get_auswahl_item' add some 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?

There is no explicit guidance about when to use this tool versus alternatives such as list_auswahl or get_wissen_entry. The description implies it is for a single Auswahl item by slug, but it never states conditions, exclusions, or sibling tool routing.

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 reinforces it with 'DOES NOT update records.' It also adds a non-obvious behavioral/data fact: 'walkIn=false — mobile only.' This is useful context beyond the annotation, though it mostly describes the business entity rather than tool behavior.

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

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

The description is four compact, scannable segments (WHO/USE/DOES NOT/NEXT) with no filler. Each segment earns its place and key information is front-loaded.

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 a single optional parameter, a full output schema, and a readOnly annotation, the description covers the scope of data, use case, exclusivity, and follow-up tools. The only small gap is an explicit statement that the tool can be called with no arguments, but the schema/context already conveys this.

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%; the locale parameter is fully documented in the schema, including its German-only behavior and ignored values. The tool description adds no parameter-level information, so the baseline 3 applies.

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

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

The description explicitly lists the returned data fields (Inhaber, brand, legalName, hours, NAP, office coords) and states 'USE for LocalBusiness / impressum-grade facts on maps.' This clearly identifies the tool as a getter for business identity and distinguishes it from update tools with 'DOES NOT update records.' It only misses a direct verb phrase, relying on the name for 'get.'

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 an explicit use case ('USE for LocalBusiness / impressum-grade facts on maps') and an exclusion ('DOES NOT update records'). The 'NEXT: get_contact, get_geo_office, get_impressum' hints at related tools but doesn't explicitly state when to choose them over this one, so the guidance is more implied than explicit.

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

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

The readOnlyHint annotation already signals a safe read; the description adds an explicit behavioral disclaimer that the tool 'DOES NOT open tickets or send messages' and contributes domain context like 'Public NAP' and 'walkIn=false'. It does not go into availability/caching details, but given the low side-effect surface and the existing annotation, this is a solid disclosure.

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 effectively front-loaded: WHAT enumerates the payload, USE gives the trigger, DOES NOT sets boundaries, and NEXT provides routing. Every sentence earns its place, and the labeled structure makes scanning easy for an agent.

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

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

For a low-complexity getter with one optional parameter, a rich parameter schema, readOnlyHint, and an output schema, the description covers purpose, usage, exclusions, and follow-up tools. Nothing an agent needs to decide to call it or interpret its side effects 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?

The tool description itself contributes no parameter-level meaning, but schema description coverage is 100% and the schema's locale description is highly detailed (German-only, default de, ignored other values, distinction from www list_locales). Per the high-coverage baseline, the schema carries the parameter semantics adequately, so no penalty beyond baseline.

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

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

The description opens with 'WHAT: Public NAP' and enumerates exactly which contact fields are returned (mobile, landline, fax, email, mapsEmail, WhatsApp, address, office coords), making the verb+resource mapping explicit. It also distinguishes itself from action-oriented siblings by stating 'DOES NOT open tickets or send messages' and listing NEXT compose tools, so an agent can tell it apart from compose_* and list_* 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?

'USE for call/WhatsApp/mail CTAs' explicitly states when the tool should be selected, and 'DOES NOT open tickets or send messages' defines exclusions. The NEXT line names the concrete alternatives (compose_tel_mobile, compose_whatsapp, compose_mailto, list_whatsapp_options) that should be used when the agent wants to take an action rather than fetch contact data.

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, so no mutation caveats are needed. The description adds that the tool reads the specific maps/llms-copyright.txt file and supports optional offset/limit, giving useful behavioral context beyond the annotation; the output schema covers return shape.

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

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

The WHAT/USE/NEXT labels make the role, trigger, and next step scannable in three short fragments with no filler.

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

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

For a read-only list/file getter with an output schema and fully documented optional pagination parameters, the description supplies the source path, language scope, and intended use. Nothing essential for choosing or invoking the tool is missing.

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

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

Schema coverage is 100%, and the schema already documents limit and offset defaults and paging behavior. The description only repeats 'Optional offset/limit' without adding new semantics.

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

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

The description states a specific verb and resource: retrieving English map copyright text from maps/llms-copyright.txt, and frames the use case as EN map authorship citations. The sibling name get_urheberrecht is called out via NEXT, which helps an agent distinguish it from the likely German 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?

'USE for EN citations of map authorship' is an explicit invocation condition. 'NEXT: get_urheberrecht' names the natural alternative, though it infers rather than states the when-not condition (e.g., German citations).

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 declare readOnlyHint; the description adds meaningful behavioral context by explicitly stating that the tool returns only a pointer/link and does NOT return the privacy policy body. This prevents the agent from expecting full policy content and sets accurate output 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 short and front-loaded with the core limitation ('www pointer only'). The 'WHAT:/NEXT:' structure is efficient, though 'maps returns html link' is slightly unclear and could be rewritten for smoother readability.

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 zero parameters, an output schema, and a readOnly annotation, the description covers the essential facts: what the tool returns, what it does not return, and the domain. It is complete enough for correct invocation, though it could name sibling alternatives for better routing.

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

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

The tool has zero parameters, so the description need not clarify parameter meanings. The baseline of 4 applies here, and the description appropriately focuses on behavior rather than inputs.

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 the resource (Datenschutz on www.ikeytz.com) and clarifies the exact behavior: it returns an HTML link/pointer, not the privacy policy body. This distinguishes it from the many sibling get_* tools, though the phrasing 'maps returns html link' is somewhat awkward.

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 explicit guidance on when to use this tool instead of related tools such as get_legal, get_impressum, or other content-returning getters. The 'NEXT: www MCP' line hints at next steps but does not explain selection criteria or alternatives.

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. The description adds value beyond that by disclosing the file format (UTF-8 text/JSON), the 1:1 mirror behavior, the optional offset/limit line window, and the behavior for missing files ('DOES NOT invent missing files (missing=true)'). This is solid supplemental behavioral context.

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

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

The description uses helpful labels (WHAT, USE, DOES NOT, NEXT) and is information-dense without being excessive. It repeats some examples already present in the schema, but the overall structure makes the key facts 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?

For a read-only retrieval tool with a fully documented schema, output schema, and readOnlyHint annotation, the description provides enough context: what the tool returns, when to use it, what it does not do, and which sibling tools to use next. Nothing critical is missing 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 100%, so the schema already documents all three parameters thoroughly. The description adds a little context via 'which is required' and 'Optional offset/limit line window', but most parameter meaning is already in the schema, and the repeated id list does not add new parameter semantics.

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

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

The description states a specific verb ('get') and resource ('maps discovery file') and clearly describes a 1:1 mirror of that file. It lists concrete discovery ids and explicitly names sibling aliases (get_llms_txt / get_ai_txt), distinguishing this tool from related getters and structured-search 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 explicitly says 'USE for agent-ready catalogs and robots/sitemap' and directs to alternatives: 'NEXT: find_by_keyword / find_by_serp for structured search'. It also tells the agent that missing files are not invented, which helps decide when this tool is 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, so the safety profile is covered. The description adds useful behavioral context beyond that, including the canonical URL form, the supported lookup modes, and the return value ('area card + canonicalUrl'). No contradiction with annotations is present.

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 well-structured with WHAT, RETURNS, USE, and NEXT labels. Every segment earns its place, and the most important information is front-loaded.

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 a fully documented input schema, an output schema, and a read-only annotation, the description covers the essential selection and invocation context. It states the use case, lookup modes, and return shape. It could be slightly stronger by mentioning when to prefer a sibling like find_by_plz or resolve_maps_url, but nothing critical is missing.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the input schema. The description merely lists slug, plz, and name as lookup keys without adding new semantic details; the schema already explains lookup order and edge cases like shared PLZ.

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

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

The description clearly states the tool's purpose: it returns the canonical map page URL for a Gebiet, for use in iframe/src and Visitenkarte. It identifies the lookup keys (slug|plz|name) and the return shape (area card + canonicalUrl). It does not explicitly distinguish itself from close siblings like resolve_maps_url, so it stops short of full sibling differentiation.

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

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

The description gives explicit usage context: 'USE for embedding or linking a Gebiet map.' This tells the agent when the tool is appropriate. However, it does not state when not to use it or mention alternatives such as resolve_maps_url, so exclusions are absent.

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, so the safety profile is covered. The description adds 'DOES NOT dispatch' and 'www pointer only,' which are useful behavioral signals, but it never defines what a 'pointer' is or what the HTML/maps distinction means for the caller.

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

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

The description is short and uses a 'WHAT'/'NEXT' structure, but it reads as telegraphic fragments ('maps returns html; use get_contact / compose_tel_mobile here for phones') rather than clear prose. Compactness is achieved at the cost of comprehensibility.

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 input schema and output schema cover the return shape and locale semantics, and the description gives some workflow context. However, the core output concept ('www pointer only') is left unexplained, and the phrase 'NEXT: compose_tel_mobile, www get_emergency' is confusing enough to leave the overall behavior incomplete.

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

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

Schema description coverage is 100%, and the locale parameter is thoroughly documented with enum, default, and behavior for ignored values. The tool description itself adds no parameter-level information, so the baseline of 3 is appropriate.

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

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

The description names a concrete resource (the Notfall-Türöffnung page) but expresses the action as 'www pointer only' rather than an explicit verb like 'returns' or 'fetches.' The phrase 'maps returns html' further blurs what get_emergency itself actually returns.

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

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

It gives useful routing guidance: use get_contact / compose_tel_mobile for phones, and it explicitly says 'DOES NOT dispatch,' which helps the agent avoid misuse. It also suggests next steps with 'NEXT: compose_tel_mobile, www get_emergency,' though it never states the positive 'use this when...' condition.

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

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

Annotations already provide readOnlyHint=true; the description adds that maps returns an HTML page and acts as a pointer to www rather than the terminal answer source. This is useful but phrased ambiguously, and the 'NEXT' instruction reads more like a directive than a disclosed behavior.

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

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

The description is short, but it sacrifices clarity for brevity, relying on jargon ('www pointer only', 'maps returns /faq html', 'NEXT:') that requires inference. It is terse but not well-structured for an agent.

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

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

The tool is simple (0 required params, no nesting, output schema present), yet the description leaves the core return value ('/faq html') and the routing semantics ambiguous. An agent cannot confidently predict what invoking this tool yields or when to chain it with the www-side get_faq.

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

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

Schema description coverage is 100%, so the schema fully documents q, id, and locale — including that locale is German-only and other values are ignored. The description's 'Optional id/q for www' restates the schema without adding new meaning, so baseline 3 applies.

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

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

The description indicates this tool is a 'www pointer' to a FAQ answer that lives on www, with maps returning '/faq html'. The verb+resource are inferable ('point to FAQ on www'), but the phrasing is cryptic and fails to plainly state what the tool does and what an agent gets back.

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 'NEXT: www get_faq' line hints that the actual answer must be fetched from a www-side tool, but it never states when to call this tool versus siblings like list_faq or get_llms_txt, nor does it explain the routing condition clearly.

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

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

Beyond the readOnlyHint annotation, the description reveals that the tool returns a URL pointer and area card rather than the polygon itself, which is critical behavioral context. It also specifies the endpoint contains point and Grenze data without delivering the polygon payload in MCP.

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 highly structured using WHAT, RETURNS, USE, and NEXT labels. Every segment adds distinct operational value, and the essential disambiguation about the polygon payload is front-loaded in the RETURNS section.

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 and the tool has three optional parameters fully documented in the schema, the description covers the needed usage context, including the endpoint, return type, and relationship to get_grenze. It is complete for an agent to select and invoke this tool correctly.

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

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

The schema already documents all three parameters in detail with 100% coverage, so the baseline is 3. The description adds only the shorthand 'Lookup slug|plz|name' without materially meaning more than the schema's parameter descriptions, though the URL pattern does clarify how slug maps to the endpoint.

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 — fetch/open the public embed JSON — and identifies the exact URL pattern with the resource ({slug}). It also distinguishes itself from get_grenze by explicitly noting what it returns and what it does not return.

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 contains an explicit 'USE' directive telling the agent when to call this tool, and a 'NEXT' pointer directing the agent to get_grenze when a GeoJSON polygon is needed. This gives clear routing between this tool and the most relevant alternative.

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 declare readOnlyHint=true, and the description adds meaningful behavioral context beyond that: 'walkIn=false always — mobile locksmith, not a shop counter' and 'DOES NOT accept walk-in customers or bookings.' It also discloses the return fields, though the output schema may already cover some of that detail.

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 well-structured with scannable labels: WHO/WHAT, RETURNS, USE, DOES NOT, NEXT. Every sentence adds useful information, and the most important behavioral constraint (walkIn=false) is front-loaded. 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?

The tool is simple: one optional, fully documented parameter and an output schema. The description fills the remaining context by explaining the business context, the return values, the intended use cases, and the walk-in limitation. For an agent needing to correctly invoke the tool, 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?

Even though the schema covers the 'locale' parameter at 100%, the description adds substantial practical meaning: 'maps is German-only (de). Omit or pass de. Other values are ignored; URLs stay https://maps.ikeytz.com/…' It also clarifies the distinction from the www multi-locale switch and points to list_locales as the alternative. This far exceeds a plain schema definition.

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: 'Gewerbesitz (registered office) coordinates and street in Ludwigsburg.' It also differentiates the tool from siblings by explicitly noting 'walkIn=false always — mobile locksmith, not a shop counter,' which prevents confusion with other location-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 gives explicit usage context: 'USE for NAP/schema or distance_to_office.' It also lists relevant next steps and clearly states what the tool does not do: 'DOES NOT accept walk-in customers or bookings.' This provides actionable guidance for selecting this tool over alternatives.

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 a safe read operation, and the description adds useful lookup behavior on top: slug-first ordering when parameters are combined, first-match-wins for shared PLZ, and case-insensitive name matching. It also states exactly what gets returned.

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

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

The description uses a compact, labeled structure (WHAT, Lookup, RETURNS, USE, NEXT) that front-loads purpose, output, and usage. Every segment earns its place, and there is no filler or redundant restating of the input schema.

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

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

For a read-only tool with three optional parameters, full schema coverage, and an output schema, the description is nearly complete: it covers lookup order, return fields, the intended use case, and related next tools. The only minor gap is not specifying what happens if none of slug/plz/name are provided, but the schema already marks all as optional.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain PLZ sharing, name fallback, and slug-first lookup order. The tool description's 'Lookup slug|plz|name' line is a concise summary but does not add meaningful semantics beyond the schema, so the baseline 3 is appropriate.

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

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

The description clearly states what the tool returns: German history text for one Einsatzgebiet Visitenkarte, with the specific lookup fields (slug, plz, name) and output fields (slug, name, geschichte). The 'USE for place history prose on the map page' line makes it easy to distinguish from the many get_* sibling 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?

It gives a clear use context ('USE for place history prose on the map page') and points to related tools in NEXT (get_lage, get_ai_page). It does not explicitly say when not to use this tool, but the map-page context and schema note about find_by_plz provide enough orientation for an agent.

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

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

With readOnlyHint=true already covering safety, the description adds meaningful behavior: it names the return fields (hasPolygon, polygon, point, osmRelationId/osmWayId, via) and clarifies the output is a GeoJSON FeatureCollection. There is 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?

The description is compact, front-loaded, and every labeled segment (WHAT, RETURNS, USE, DOES NOT, NEXT) earns its place. It packs purpose, return fields, usage trigger, and an exclusion into a few short lines.

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

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

For a read-only lookup with an output schema, the description covers what the tool returns, when to use it, and what it does not replace. It does not state behavior when no parameters are supplied or when lookup fails, but the schema and output schema already carry much of that burden.

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

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

Schema coverage is 100% and the schema already explains slug priority, PLZ first-match behavior, and name substring matching. The description only restates 'Lookup slug|plz|name', adding no new parameter semantics 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 identifies a specific verb+resource: returns the OSM Gebietspolygon for one Einsatzgebiet as a GeoJSON FeatureCollection, with lookup by slug|plz|name. It actively separates itself from get_geo_api by stating it is not the URL pointer, so the tool's unique purpose is 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?

It gives an explicit trigger ('USE when the agent needs the boundary geometry') and an explicit counter-rule ('DOES NOT replace get_geo_api'). It does not, however, explain when to prefer related siblings like get_lage/get_embed_map or find_by_plz, so the routing guidance is good but not exhaustive.

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

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

Annotations already declare readOnlyHint=true. The description adds value beyond that by describing the response shape ('title/h1 + 52 Gebiet links') and a meaningful limitation ('DOES NOT include www prices'). This is useful behavioral context 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 WHAT/USE/NEXT sections, and nearly every fragment adds value. The 'Call with {}' fragment is redundant with the schema, but the overall structure is highly scannable and efficient.

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

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

For a zero-parameter read-only tool with an output schema, the description supplies everything needed to select and invoke it: purpose, resource URL, expected content, exclusions, and follow-up tools. Nothing important appears 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?

The tool has zero parameters and schema description coverage is 100%, so there is no parameter burden for the description to carry. The description's 'Call with {}' merely restates what the schema already states, but no additional parameter semantics are 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?

The description states a specific resource ('maps hub card at https://maps.ikeytz.com/'), exactly what it returns ('title/h1 + 52 Gebiet links'), and what it is not ('not a single Visitenkarte'). This clearly distinguishes it from sibling get_* tools that return individual entries.

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 to use this as 'the maps landing overview' and notes it 'DOES NOT include www prices,' which is a useful exclusion. It names follow-up tools ('NEXT: get_service_area, list_service_areas'), though it does not spell out explicit when-not-to-use conditions for every sibling.

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 establishes that this is a safe read operation. The description adds useful behavioral context by naming the exact source file and clarifying that the content is plain-text NAP/legal imprint. It does not contradict the annotation and gives enough beyond the schema to help an agent understand what this tool actually reads.

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

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

The description is extremely compact and front-loaded: WHAT names the resource first, USE gives the purpose, and NEXT supplies routing to alternatives. Every clause carries useful information with no filler.

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

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

For a simple read-only paginated text retrieval tool with 0 required parameters and a full output schema, the description covers the source, purpose, pagination option, and sibling alternatives. Nothing essential is missing for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents offset and limit with detailed semantics. The description only repeats 'Optional offset/limit', adding no new meaning beyond the structured parameter definitions.

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 resource ('maps /llms-impressum-kontakt.txt') and a clear purpose: retrieving Impressum/Kontakt text for NAP/legal imprint on maps. It also distinguishes itself from sibling tools by pointing to get_contact and get_business_identity as next steps and noting the HTML variant is at /impressum.

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

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

The 'USE for NAP/legal imprint on maps' phrase gives a clear intended context. The 'NEXT' pointer provides alternatives, but it does not explicitly state when to choose those alternatives over this tool, so it stops short of a full when/when-not specification.

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 declare readOnlyHint; the description goes well beyond that by disclosing that the tool returns no totalEur, ignores whenKey/breakdown for the pointer payload, is German-only, and leaves URLs without a locale prefix. These are exactly the unexpected behaviors an agent needs to know.

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

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

Three dense sentences with WHAT/NEXT labels and front-loaded scoping; no filler. One minor deduction because the 'NEXT:' line is a slightly cryptic developer-style pointer rather than a plain instruction, though it remains informative.

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

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

The description, schema, readOnly annotation, and output schema together cover return type, ignored params, locale behavior, and the correct alternative tool. It is complete for a pointer tool, but the situationKey requirement ambiguity and the unexplained 'Berlin clock/whenKey' reference keep it from being fully self-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 covers 100% of parameters and already documents locale, whenKey, breakdown, and situationKey. The description adds useful 'for symmetry' semantics that the params are mostly ignored in the maps pointer payload. However, the situationKey description says 'Required for www' while the schema marks it required here, leaving some ambiguity about whether/how it is required on maps.

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 immediately identifies the tool as a 'www pointer only' and states exactly what it returns: an html link to /preise, not totals, and explicitly 'DOES NOT return totalEur.' This distinguishes it from the actual @ikeytz/mcp get_invoice_line_items tool and from siblings like get_prices.

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 names the proper alternative for real invoice line items ('NEXT: @ikeytz/mcp get_invoice_line_items') and routes whenKey/Berlin-clock needs to get_ort_datetime here. The 'maps accepts ... for symmetry' phrasing tells the agent this maps tool is only for pointer/link purposes, giving clear when-to-use versus when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Lookup' and 'RETURNS' wording confirms a read-only operation. The description adds the single-object scoping ('for one Einsatzgebiet'), which is useful, but it doesn't go into edge cases like first-match-wins behavior — that detail lives in the parameter schema. This is adequate given the annotation coverage.

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

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

The description is compact and front-loads the key information with clear 'WHAT', 'RETURNS', 'USE', and 'NEXT' labels. Every sentence earns its place and there is no filler or redundancy.

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

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

For a simple read-only lookup tool with full parameter schema coverage and an output schema present, the description covers selection context (geography prose), lookup keys, and return fields. The schema handles the remaining edge cases (e.g., first-match PLZ), so nothing critical is missing for an agent to invoke this correctly.

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

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

Schema description coverage is 100%: each parameter (plz, name, slug) is already well documented with examples and lookup rules. The description only restates the lookup keys as 'slug|plz|name', adding no new meaning beyond the schema. A baseline 3 is appropriate.

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

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

The description states a specific resource ('Lage (location description) text for one Einsatzgebiet Visitenkarte'), the lookup keys (slug|plz|name), and the exact return fields (slug, name, lage). This is unambiguous and distinguishes the tool from siblings like get_geschichte and get_service_area by its geography-prose focus.

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

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

The 'USE for human-readable geography prose' phrase gives a clear context for when to select this tool. It also names related next tools ('NEXT: get_geschichte, get_service_area'), but does not explicitly state when those should be used instead of this one, so it stops short of full exclusion logic.

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?

readOnlyHint already signals a safe read operation, and the description adds meaningful behavioral context: maps docs are served via discovery text, www docs return only URL pointers, and the tool intentionally excludes www legal HTML bodies. This is beyond what the annotation alone conveys.

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 labeled WHAT/USE/NEXT format packs a lot of information into a very compact space with no filler. Each segment earns its place, and the most important routing distinction is front-loaded.

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

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

With an output schema present and rich parameter documentation, the description covers the essential routing behavior, citation use case, and exclusions. It could be slightly clearer about how locale interacts with the maps vs www split, but the schema already covers that.

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 thoroughly. The description mostly paraphrases the doc enum split and the offset/limit applicability rather than adding new semantic detail, so the baseline 3 applies.

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

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

The description opens with a clear 'Legal doc router' identity and enumerates the exact doc values split by maps vs www behavior. It distinguishes itself from the many sibling get_* legal tools by specifying what it serves and pointing to get_urheberrecht/get_impressum as shortcuts.

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 explicitly states 'USE for citations,' clearly says this tool 'DOES NOT serve www legal HTML body on maps,' and names the relevant alternatives: get_urheberrecht/get_impressum shortcuts and www for AGB body. This gives the agent actionable when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is known. The description adds that the tool maps URLs and serves as a bookmark set, which gives some behavioral context. It doesn't contradict annotations and doesn't overpromise. With annotations covering safety and an output schema present, this is sufficient.

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

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

The description is extremely concise and well-structured with clear labels (WHAT, USE, NEXT). It front-loads the core purpose, adds a practical usage note, and identifies follow-up tools—all in three short segments with zero waste. Excellent formatting for agent consumption.

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 optional parameter and an output schema, the description is mostly complete. It states what URLs are covered, how to use it, and what to do next. The only minor gap is that it doesn't describe the output format, but the output schema likely handles that. The presence of annotations further reduces the burden.

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

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

Schema description coverage is 100%, and the schema's description for the locale parameter is detailed: it explains allowed values ('de'), the default, that other values are ignored, and points to an alternative for multi-locale. The tool description itself doesn't mention parameters, but since the schema fully covers it, the baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: 'maps discovery URLs' and explicitly lists the types of URLs covered (hub, mcp, server-card, agent-skills, llms, registry search, npm). It also adds a usage note ('USE as the machine bookmark set'), which clarifies its role. However, it doesn't explicitly differentiate from sibling tools beyond mentioning get_discovery and get_llms_txt as next steps, so it's clear but not perfectly differentiated.

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

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

The description gives a usage suggestion ('USE as the machine bookmark set') and points to next tools, implying when to follow up. It doesn't explicitly state when not to use this tool or compare with alternatives. The schema description for locale does provide an alternative for locales (list_locales on www), but the main description lacks such exclusions, so usage guidance is adequate but not explicit.

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

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

Annotations already declare readOnlyHint=true, and the description adds the disclosure that this is an alias of get_discovery and returns 'machine/catalog text'. This gives useful semantic context beyond the structured fields, though it does not describe pagination clamps or output formatting in detail.

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, labeled, and front-loaded with WHAT, USE, and NEXT. Every clause provides actionable information with no filler.

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

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

The tool is simple, has an output schema, readOnlyHint annotation, and the description covers its alias relationship, purpose, and next-step siblings. Nothing an agent needs to select and invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description only restates that offset/limit are optional and does not add substantive meaning beyond the schema.

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

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

States it is an alias of get_discovery(which=llms-mcp-server) for serving the maps MCP catalog, which is a specific verb+resource. The reference to sibling tools get_llms_mcp_web and get_links helps differentiate it from neighboring retrieval 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?

Explicitly states when to use it ('USE when an agent needs the server-side llms MCP catalog') and points to follow-on alternatives with 'NEXT'. It stops short of explicitly naming situations where another sibling should be chosen instead, so it is clear context without full exclusions.