ikeytz Einsatzgebiet-Karten

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

Annotations declare readOnlyHint=true, so safety is already covered. The description adds genuinely useful behavioral context beyond that: "DOES NOT send mail" clarifies that this only produces a link rather than performing an action, and "Call with {}" confirms the no-argument invocation. It stops short of any rate-limit or format nuance, but for a pure constructor tool that is minor.

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

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

A single tight block with WHAT / USE / DOES NOT front-loaded, so the agent gets purpose, routing, and the key caveat in one pass. Every clause earns its place with no filler.

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

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

An output schema exists, so return-value structure needn't be re-explained; the description still names the salient returned fields. For a zero-param constructor tool with annotations, nothing needed to call 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?

Zero parameters, so the baseline is 4. The description's "Call with {}" is consistent with the empty schema and adds the one piece of invocation guidance an agent needs, though it only restates what the schema already enforces.

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: it returns a mailto: link plus a mapsEmail/mapsHref value. It also names sibling tools (compose_whatsapp, compose_tel_mobile) so an agent can distinguish it from other contact-channel composers without opening schemas.

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

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

"USE for email CTAs" gives the triggering condition, and "Prefer compose_whatsapp or compose_tel_mobile when the user wants chat or a phone call instead" explicitly names the alternatives and the intent that selects them. Nothing about when-to-use is left to inference.

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

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

readOnlyHint=true already signals a safe read operation. The description adds value by confirming it is argument-free ('Call with {}') and naming the return shape, but discloses no further behavior beyond the annotation's coverage, so a mid score is appropriate.

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

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

Four labeled fragments (WHAT/RETURNS/USE/NEXT) with zero waste, front-loading the core purpose before return info and routing. Every clause earns its place.

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

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

For a zero-argument tool with an output schema documenting the return values, the description covers purpose, no-arg invocation, and sibling routing. Little is missing, though it could note when the landline is preferred over mobile.

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

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

The tool takes zero parameters, so the baseline is 4. The description reinforces this with 'Call with {}', aligning with the schema's no-argument contract without needing further elaboration.

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 ('tel: href for the public landline') and differentiates from the mobile sibling ('secondary call CTA', 'NEXT: compose_tel_mobile'). An agent can tell it apart from compose_tel_mobile without opening either schema.

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

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

'USE as secondary call CTA' gives clear usage context and 'NEXT: compose_tel_mobile' routes to the alternative call tool. It does not explicitly state when the mobile option should be preferred, so the guidance is clear 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 only declare readOnlyHint=true; the description adds the important behavioral clarification that this composes a link and does not actually dial, which is a real side-effect distinction. It also names the return shape, though an output schema exists and already carries that. Solid added value, but not rich on constraints.

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 labeled fragments, zero filler, front-loaded with WHAT and the return value before routing guidance. Every clause earns its place.

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

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

With no parameters, readOnlyHint already declared, and an output schema covering href and display, the description supplies exactly the missing pieces: what the artifact is for and which sibling to use instead.

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?

Zero parameters, so the baseline is 4. The description reinforces this with 'Call with {}', which matches the schema's statement that no arguments are needed and extra keys are ignored.

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: produces a 'tel: href for the public mobile number'. The word 'mobile' plus the explicit sibling routing to compose_tel_landline lets an agent separate it from the other compose_* tools without opening a schema.

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

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

Gives the positive case ('USE as the primary call CTA'), the exclusion ('DOES NOT place the call'), and names the follow-on alternatives (compose_tel_landline, list_whatsapp_options). Nothing about tool selection is left to inference.

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

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

Annotations only give readOnlyHint=true; the description goes well beyond by disclosing deprecation aliases and their side effect (ambiguous=true), the omit-option fallback (bare wa.me), and the error contract (ok:false unknown_option + hint ids). That is meaningful behavioral context an agent could not infer from the schema or 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?

Telegraphic and front-loaded: WHAT, then parameter semantics, then USE/NEXT. Every clause carries information (aliases, error contract, scope limit) 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?

With an output schema present, return values need not be described, and the description still covers the key failure shape (ok:false). For a one-optional-parameter read-only link builder, nothing an agent needs to call 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 coverage is 100%, so baseline is 3, but the description adds real meaning: the option namespace (12 www ids), the deprecated zugefallen|abgeschlossen|zylinder aliases mapping to *day*, and the unknown-value failure mode. It does not enumerate all 12 ids or their distinctions, which caps it below 5.

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

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

States a specific verb+resource ('wa.me link with prefab') and makes the artifact type unambiguous ('Link only — no form'). It clearly distinguishes itself from the tel/mailto siblings by naming its channel and its option parameter.

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' plus 'NEXT: compose_mailto, get_contact' gives the calling context and points at sibling alternatives. It stops short of stating when NOT to use it (e.g., no option vs. another channel), so it is strong but not exhaustive.

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

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

Annotations only supply readOnlyHint, so the description carries most of the burden and does deliver: it discloses the return fields (from, office, distance_km), the no-routing behavior (must not be read as an ETA), and the walkIn=false mode. It does not explain what happens on a failed place lookup or on ambiguous PLZ/name matches.

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

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

Front-loaded WHAT / RETURNS / USE / NEXT labels make it scannable and every clause earns its place, with zero filler prose. The telegraphic fragments "walkIn=false" and "NEXT:" assume vocabulary the reader may not have, costing a point.

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?

Output schema exists, so the RETURNS line is a helpful bonus rather than a necessity, and the input families are fully covered by the schema. The notable remaining gap is that all six parameters are optional, and the description never says what the tool returns when invoked with no arguments at all.

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

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

Schema description coverage is 100%, so every one of the six parameters is already documented in the schema, including the slug>plz>name precedence. The description only restates the accepted input families (slug|plz|name or lat/lng/icbm), adding no syntax or precedence detail beyond the schema — baseline 3.

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

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

States a specific verb+resource (air distance in km from a Gebiet or coordinate pair to the Gewerbesitz) and immediately bounds it against the nearest confusing sibling by declaring it is NOT driving time and does NOT route via OSRM. An agent can distinguish this from routing/geo-lookup tools without opening a schema.

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

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

"USE for rough proximity — not driving time" gives an explicit when-to-use plus an explicit exclusion, which is more than most siblings offer. It stops short of saying when get_geo_office or find_by_geo should be chosen instead; "NEXT" reads as a chaining hint rather than an alternative selection rule.

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 annotations: multi-match behavior, substring matching, umlaut tolerance, no exact-slug requirement, and same match rules as find_by_gebiet. It stops short of detailing pagination or match limits, but with an output schema present that is acceptable.

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/RETURNS/USE/DOES NOT/NEXT structure is front-loaded and scannable. Every clause carries selection or behavior 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 read-only multi-match lookup with 100% schema coverage and an output schema, the description supplies everything needed: purpose, matching semantics, alternatives, exclusions, and follow-up tools. No critical decision or invocation detail 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 baseline is 3. The description still adds cross-parameter meaning by grouping q, name, and slug as substring-capable inputs with umlaut support and by clarifying that an exact slug is not required, which goes beyond the individual schema field descriptions.

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

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

States a specific verb and resource: multi-match Einsatzgebiete by q, name, or slug with substring and umlaut support, returning all matching point cards. It also explicitly distinguishes itself from find_by_gebiet and find_by_plz, so an agent can select it without opening sibling schemas.

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

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

Provides explicit when-to-use guidance ('USE for fuzzy place names'), an exclusion ('DOES NOT require an exact slug'), and named alternatives ('Prefer find_by_plz for postcode-only queries'). It also recommends this name when the agent thinks in 'area' wording, resolving ambiguity with find_by_gebiet.

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 covers the safety profile, and the description adds real value beyond it: substring matching, umlaut tolerance, and crucially 'RETURNS all matching point cards' (multi-match semantics, not a single result). It omits any note on result limits or ordering when many Gebiete match, which is the one behavioral gap left.

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?

Labeled WHAT/RETURNS/USE/DOES NOT/NEXT structure is front-loaded and terse, with every clause carrying a distinct fact (matching mode, return shape, usage condition, follow-up). No filler sentences.

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 full output schema covering return values and annotations covering safety, the description only needs to establish fuzzy-match semantics, which it does. Given the crowded find_by_* sibling set, a brief note on how it differs from find_by_plz or find_by_keyword would make it fully complete for selection.

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

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

Schema description coverage is 100%, so q, name, and slug are already fully documented, including the slug-first lookup order. The description restates that lookups accept q/name/slug without adding format, precedence, or fallback detail the schema lacks; baseline 3 applies when the schema carries the parameter burden.

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

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

States a specific verb+resource ('Multi-match Gebiete by q, name, or slug') with substring/umlaut qualifiers, so the agent knows this is fuzzy lookup rather than exact. It does not name the exact-match siblings (find_by_plz, find_by_serp) to contrast against, so the differentiation is by implication rather than by explicit callout.

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 fuzzy place names' and 'DOES NOT require exact slug' give clear positive context plus one exclusion that separates it from exact-slug lookups. 'NEXT: get_service_area for one, or get_grenze' usefully routes follow-up calls, though it stops short of naming the sibling to prefer when the name is already known exactly.

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 carries real additional weight: it discloses the error path ((0,0) and far points yield ok=false outside_service_area) and that results carry distance_km. That is meaningful behavior beyond the annotation, though it says nothing about ordering guarantees or how many results a radius query can return.

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?

What/Returns/Use/Does-not/Next structure is aggressively front-loaded and each clause carries information; nothing is padding. The terse label style still parses cleanly.

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

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

An output schema exists and annotations cover the safety profile, so the description need not explain return payloads; it still adds the coordinate-alternative, default-limit behavior and error condition. The only residual gap is disambiguating this from find_by_icbm/find_by_gebiet for an agent choosing among near-identical 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 coverage is already 100%, so the schema defines lat, lng, icbm, limit and radius_km in full. The description restates the radius-vs-limit default (nearest N, default 5) rather than adding syntax or edge-case meaning not already present in the schema text, 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?

States a specific verb and resource: rank Einsatzgebiete by lat/lng or icbm, with the exact filter semantics (radius_km vs nearest N). It also distinguishes itself from routing siblings by declaring 'DOES NOT route or drive-time,' so an agent can separate it from distance_to_office without opening a schema.

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

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

Gives an explicit trigger ('USE for near this coordinate'), an explicit exclusion (no routing/drive-time), and names follow-up tools (get_service_area, get_grenze, distance_to_office). It does not, however, clarify when to prefer this over the very similarly named find_by_icbm sibling, which remains an inference the agent must make.

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=true already declares the safety profile, so the bar is lower. The description still adds real behavior beyond annotations: the (0,0) → outside_service_area sentinel and the shared ranking with find_by_geo. It stops short of stating output shape or fallback behavior when a pin is far outside the service area.

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 telegraphic clauses with WHAT/USE/NEXT labels, front-loaded and free of filler. Every sentence carries a distinct piece of operational information.

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

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

An output schema exists, so return values need not be explained. Input alternatives, the out-of-area sentinel, and next-step tools are all covered; the only remaining gap is differentiation from the overlapping find_by_icbm sibling.

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 baseline is 3. The description restates the accepted input forms ('q or icbm or lat/lng') and the (0,0) sentinel, but that information is already fully in the schema, and it adds no new constraint (e.g., which form takes precedence) beyond what is documented there.

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

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

States a specific verb+resource ('Paste ... coordinates → nearest ikeytz Gebiete') and anchors the ranking to a sibling ('same ranking as find_by_geo'), so an agent can tell it apart from the geo/icbm finders. The WHAT label makes the purpose scannable.

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 when the user pastes a Maps pin' gives an explicit triggering condition, and 'NEXT: get_service_area, get_embed_map' routes follow-up. However it does not disambiguate from the sibling find_by_icbm, which the description openly overlaps with ('Google Maps / ICBM coordinates ... or icbm').

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 carries most of the behavioral load and delivers: the return payload (items with distance_km), edge-case semantics ((0,0)/far points yield ok=false outside_service_area), and explicit non-capability (no routing/drive-time). It stops short of noting pagination behavior or clamps beyond what the schema already says.

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

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

A tight WHAT / RETURNS / USE / PREFER / edge-case / DOES NOT / NEXT structure with zero filler; the identifying information and the sibling routing are 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 read-only lookup with a 100%-covered schema, an output schema and readOnlyHint annotation, the description supplies everything else an agent needs: trigger, alternative, error semantics and follow-up tools.

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 lat, lng, icbm, limit and radius_km are all documented in the schema. The description only restates which parameters exist and that they are optional, adding no syntax or semantics beyond that — 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?

States a specific verb (rank) and resource (Einsatzgebiete) plus the exact input form (an ICBM 'lat, lng' string), and explicitly distinguishes itself from the closest sibling, find_by_geo. An agent can choose between the two without opening either schema.

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

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

Gives a concrete trigger ('USE when the user pastes ICBM metadata'), names the alternative and its selecting condition ('Prefer find_by_geo instead for plain lat/lng without an ICBM string'), and states a negative scope ('DOES NOT route or drive-time') plus NEXT-step tools.

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

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

Annotations already declare readOnlyHint=true, so safety is covered, but the description adds useful behavior beyond that: it returns 'matching keyword/url rows' and notes the limit is 'clamped', warning the agent that results may be truncated. No auth or rate-limit context, but the added return/clamp detail is meaningful.

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

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

Front-loaded with labeled sections (WHAT/RETURNS/USE/DOES NOT/NEXT) and every clause carries information with almost no filler. The telegraphic style is dense but efficient, with no duplicated sentences.

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

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

An output schema exists so return-shape detail is not required, yet the description still summarizes the returned rows and the next-step tools. Combined with the explicit exclusion and required-param note, an agent has enough to invoke it correctly, though deployment context like indexing scope is left implicit.

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, limit, and locale in detail. The description only echoes 'q required', adding no format or syntax guidance beyond what the schema already provides, which matches the baseline 3 for fully-covered schemas.

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-keywords.txt (keyword → maps URL)'. It explicitly scopes itself against the sibling space with 'DOES NOT search www keywords', so an agent can distinguish it from the other find_by_* and list_* tools without opening the schema.

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

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

Gives clear when-to-use ('USE for SEO/keyword → Gebiet page'), an explicit exclusion ('DOES NOT search www keywords'), and follow-up routing ('NEXT: get_service_area / get_embed_map with the slug from the URL'). It stops short of naming a directly competing alternative tool for the same query, so it is strong but not maximal.

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 behavior beyond that: it discloses the return shape (items[] point cards + count) and the completeness guarantee (returns ALL matches, not just the first). No pagination or error-mode detail, which keeps it short of a 5.

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

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

Telegraphic WHAT/USE/NEXT framing is front-loaded and wastes nothing. Each clause carries distinct information: scope, input, output, trigger, and next step.

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

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

An output schema exists, so return-value explanation is not required, and the annotations carry the read-only safety signal. The description still covers scope, input alias, result completeness, and handoff, leaving nothing an agent needs 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 description coverage is 100% and both parameters are already documented, including the 'q as alias for plz' relationship. The description restates 'plz required (or q as PLZ)' without adding syntax or format constraints beyond the schema. Baseline 3 applies when 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?

States a specific verb+resource ('All Einsatzgebiete with this PLZ') and immediately scopes the result set ('not only the first'). This distinguishes it from single-result siblings like get_service_area and from other find_by_* variants.

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

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

Gives an explicit trigger ('USE when several Stadtteile share a postcode') and routes to the follow-up tool for the single-card case ('NEXT: get_service_area(slug)'). The when-to-use and alternative path are both spelled out.

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 only readOnlyHint available, the description adds real behavioral context: it discloses it does not scrape live HTML, names the underlying source catalog URL, and indicates the item shape (path/url/snippet). It does not cover pagination limits or combined-filter 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?

Tagged WHAT/RETURNS/USE/DOES NOT/NEXT structure is well front-loaded and scannable. Slightly dense with some overlap between the WHAT clause and the parameter list.

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 a full schema and an output schema, this covers purpose, negative constraints, and the follow-up call. The remaining gap is filter-combination semantics, which matters given four optional, non-required query parameters.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, giving a baseline of 3. The description restates the query keys but adds nothing about how they combine, precedence when multiple are supplied, or matching semantics for q.

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') and enumerates the four lookup keys (q, path, url, slug). It also distinguishes itself from sibling lookup tools by clarifying it searches the SERP block catalog rather than 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?

'USE for title/H1/description SERP cards on maps' gives a clear usage context, and 'NEXT: get_serp_snippet for one full block' routes the agent to the follow-up tool. It lacks explicit exclusions against close siblings like find_by_gebiet or find_by_keyword, so 4 rather than 5.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds scope-level behavioral context: the host is German-only, the returned corpus is not the www Über-uns body, and it flags the shared-card overlap with site_overview. That is useful beyond the annotation.

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

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

Telegraphic WHAT/USE/DOES NOT/NEXT labeling is front-loaded and wastes no words. Every clause carries routing or scope information.

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

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

An output schema exists, so return values needn't be explained, and the single param is fully covered. Usage, scope boundaries, and follow-ups are present; only the direct site_overview-vs-get_about selection rule is left implicit.

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 locale enum already documents the German-only behavior and the no-prefix URL rule in full detail. The description adds nothing about the locale parameter, so baseline 3 is correct when the schema carries the semantics.

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

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

States a specific verb/resource (About page for maps.ikeytz.com) and immediately differentiates it from siblings: 'same core card as site_overview' and 'not www Über-uns corpus'. An agent can distinguish it from site_overview and get_impressum without opening a schema.

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

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

Explicit USE trigger ('what is this host') and a NEXT list (site_overview, get_links, get_business_identity). It also carves out a negative ('DOES NOT return www about body'), but it doesn't fully spell out when to prefer site_overview over this tool given they share a core card.

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 meaningful behavioral context beyond that: its output is a URL only, not clause text, which prevents the agent from expecting a legal corpus, and it disclaims clause invention. It doesn't discuss latency or failure modes, but the output nature is a valuable addition.

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 front-loaded sentences in a clear WHAT/USE/DOES-NOT structure, each earning its place with no waste. The most important constraint (URL only) comes first.

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

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

An output schema exists so return values needn't be spelled out, yet the description still clarifies the output is a link. For a zero-parameter, annotated, read-only helper, nothing an agent needs to select and call 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?

The tool takes zero parameters and the schema documents this fully ('This tool takes no arguments'), so the baseline is 4. The description correctly implies a no-argument call, adding no confusion.

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 and sharply scopes it: 'Returns only a URL to www.ikeytz.com/agb — not AGB clause text.' It explicitly distinguishes itself from siblings get_legal(doc=agb) and www get_agb, so an agent can pick it apart from near-identical 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 an explicit use condition ('USE when the user asks for AGB while on maps and you only need the link') and names the alternatives with the condition that selects them ('Prefer ... get_legal(doc=agb) ... when you need the legal corpus'). Both when-to-use and when-not-to-use are covered.

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

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

Annotations only declare readOnlyHint=true, so safety is covered. The description adds branch behavior (txt corpus vs HTML hand-off) and the guarantee 'DOES NOT invent page bodies', but does not mention auth needs, caching, or rate limits. With an output schema present, return values need not be re-explained, so a 3 is appropriate.

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

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

Front-loaded with WHAT/USE/NEXT labels and no filler sentences, though the two inline URLs and the 'Not a www multi-locale switch' tangent add density. Nothing is truly wasted, but the entry is cramped.

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 tool with an output schema and full param coverage, the description supplies the branch logic, the sibling routing, and the doc URLs an agent needs. It leaves minor gaps around error cases for invalid slugs, but is broadly 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% with 3 well-documented params including an enum and its locale caveat. The description only restates 'path or slug', adding nothing beyond the schema. Baseline 3 for a fully-documented 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 opens with a specific verb+resource ('Reads maps /ai-pages/de/{slug}.txt') and clarifies the fallback branch for non-maps paths. It distinguishes itself from get_ai_txt. However, the phrasing around 'www HTML hand-off' is somewhat tangled, so an agent must parse carefully to distinguish it from sibling page 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?

Explicit 'USE for agent-ready maps Gebiet prose — not for site-wide crawl policy (that is get_ai_txt)' names both the intended use and the exclusion, plus NEXT suggestions. It stops short of a full when/when-not matrix for the many other get_* page tools, but the key routing is present.

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

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

Annotations only declare readOnlyHint=true, so the description carries most of the burden. It adds useful context that this is an alias of get_discovery and a 1:1 map of /.well-known/ai.txt, which helps predict output. However it discloses no pagination/truncation behavior or content expectations beyond that, leaving gaps for a discovery-file reader.

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

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

A single front-loaded line in WHAT/USE/NEXT form with zero filler. Every clause earns its place: identity, use condition, and next step.

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

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

An output schema exists, so return values need not be explained. With purpose, use condition, and next-step routing covered, the definition is nearly complete; only a note on what the file typically contains (beyond crawl/train policy) is absent.

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

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

Schema description coverage is 100% and both limit/offset are documented in extensive detail in the schema (windowing, nextOffset, 1..10000 caps). The description adds nothing about parameters, so the baseline 3 applies — the schema does all the work.

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

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

States a specific verb+resource via an explicit alias relationship: 'Alias get_discovery(which=ai-txt) — maps /.well-known/ai.txt 1:1.' This distinguishes it from sibling get_discovery and get_llms_txt. It is clear what the tool returns (the ai.txt file content), though the aliasing framing makes the agent infer the fetch action rather than naming it directly.

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 crawl/train policy (ai-train=no)' gives an explicit use condition, and 'NEXT: get_llms_txt' routes the agent to the follow-up tool. No when-not or explicit alternative exclusion is given, but the positive guidance is concrete.

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

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

Annotations only provide readOnlyHint=true, and the description adds useful scope context beyond that: it returns a URL, not article text, and it is maps-specific rather than a www multi-locale switch. It does not cover auth or rate limits, but for a read-only lookup with an output schema the added clarity is strong.

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

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

Front-loaded WHAT/USE/DOES-NOT structure with no wasted sentences. Slight redundancy between 'not the Auswahl article body' and 'DOES NOT return article text', but overall tight.

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, the output schema exists so return structure needn't be restated, and the description still confirms the returned artifact (a URL). Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100% and the locale semantics are fully documented in the schema itself (German-only, ignored for others). The description only restates that slug is required, adding no syntax or format detail beyond the schema, 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?

States a specific verb+resource and precise scope: it returns only a URL to www /auswahl/{slug}, explicitly not the article body. It also differentiates itself from list_auswahl and the www MCP's get_auswahl_item, so an agent can distinguish it without opening other schemas.

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

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

Gives explicit when-to-use (user names a specific Auswahl slug on maps) and names two alternatives with the condition that selects each: list_auswahl for the hub link, www MCP get_auswahl_item for the full article. No inference required.

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=true already declares the safe-read profile, so the bar is lower. The description still adds real context beyond annotations: it flags 'walkIn=false — mobile locksmith only' and states it does not update records or accept bookings. It does not discuss rate limits or auth needs, but given the annotation coverage this is solid.

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

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

Front-loaded with WHAT/USE/DOES NOT headers that make scanning easy. Slightly redundant, as the no-walk-in constraint appears twice ('walkIn=false — mobile locksmith only' and 'accept walk-in bookings'), but overall tight and well organized.

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

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

An output schema exists, so return values need not be restated. For a single-optional-param, read-only lookup the description covers purpose, selection vs alternatives, and exclusions; nothing an agent needs to call 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 coverage is 100% and the sole parameter carries a thorough enum description, so the schema does the heavy lifting. The description only reinforces calling with {} or locale=de, adding no syntax or meaning beyond the schema, which matches the baseline 3.

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

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

States a specific verb and enumerates exactly what is returned (Inhaber, brand, legalName, hours, NAP, office coords) and the scope (LocalBusiness / impressum-grade facts). It explicitly distinguishes itself from the three closest siblings (get_contact, get_geo_office, get_impressum), so an agent can select it without opening any schema.

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

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

Provides an explicit USE condition plus three named alternatives with the exact condition that selects each (phone/email CTA, /buero pin and embed, full imprint text). It also states two exclusions (no record updates, no walk-in bookings), leaving little to inference.

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

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

Annotations only declare readOnlyHint=true, so the description must add the rest; it does disclose that the tool is a pure data fetch that sends nothing and opens no tickets, plus the walkIn=false flag. It does not discuss caching, freshness, or failure modes, but it covers the behavior an agent needs to avoid misusing it as a messaging 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?

Front-loaded WHAT/USE/DOES NOT/NEXT structure with zero filler sentences; every clause earns its place. The telegraphic label style is dense but readable, at most slightly clipped for less common terms like mapsEmail.

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, return-value documentation is unnecessary, and the description covers payload contents, negative scope, and next-step routing for a read-only one-param tool. The only omission is any mention of the locale behavior, which the schema already handles, so 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% and the single locale parameter is documented in exhaustive detail inside the schema (German-only, ignored values, www multi-locale pointer). The description adds nothing about locale, so the baseline 3 applies — the schema carries this dimension entirely.

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

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

States a specific verb+resource and enumerates the exact payload (mobile, landline, fax, email, mapsEmail, WhatsApp, address, office coords), so an agent knows precisely what it retrieves. The 'DOES NOT' clause and the NEXT routing to compose_* siblings distinguish it from adjacent tools without opening any schema.

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

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

Explicit when-to-use ('USE for call/WhatsApp/mail CTAs'), explicit exclusions ('DOES NOT open tickets or send messages'), and named alternatives (compose_tel_mobile, compose_whatsapp, compose_mailto, list_whatsapp_options). Nothing is left to inference about when this tool is the right pick.

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 declares this a safe read. The description adds that content comes from a static text file (llms-copyright.txt), which is useful context about the source and stability, but it discloses nothing about the size-window/pagination behaviour, which is instead carried by the schema. Modest added value over 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?

Three telegraphic clauses (WHAT/USE/NEXT) with the core purpose front-loaded and zero filler. The terse label style is efficient, though 'NEXT' is cryptic enough that a fully polished definition would spell it out.

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 text fetch with an output schema and 100%-covered parameters, almost everything an agent needs is present: what it returns, its source, when to use it, and the German sibling. Only the meaning of the 'NEXT' chain is left slightly ambiguous.

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

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

Schema description coverage is 100% and both parameters have detailed prose in the schema covering defaults, ranges, and the 30KB window behaviour. The description only repeats 'Optional offset/limit', adding no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (get) and resource (English map copyright text) plus the exact source (/llms-copyright.txt), and explicitly sets itself apart from the sibling get_urheberrecht. An agent can distinguish it from the many other get_* legal/page tools without opening the schema.

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

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

'USE for EN citations of map authorship' gives a genuine when-to-use condition, and 'NEXT: get_urheberrecht' points at the German counterpart. However the routing is stated as 'NEXT' (suggesting a chained follow-up) rather than an explicit alternative or exclusion, so the when-not guidance is only implied.

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 genuinely useful behavioral detail beyond that: it returns only a URL and not the policy body, and it 'DOES NOT invent privacy clauses,' which tells the agent not to synthesize content. Auth/rate-limit behavior is unspecified but unimportant for a read-only URL lookup.

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

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

The WHAT/USE/DOES-NOT structure front-loads the essential fact (URL only, not the body) and each sentence carries information. The repeated 'www' qualifier and the terse 'www Datenschutz' phrasing are slightly opaque, but nothing is padded.

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

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

With an output schema present, the description needn't enumerate return values, and it already states the return is a URL. For a zero-parameter, read-only lookup with annotations covering safety, the agent has everything needed to select and 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?

The tool takes zero parameters, which is the baseline-4 case. The schema itself states no arguments are accepted and that extra keys are ignored, so no additional parameter explanation is required from the description.

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

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

States a specific verb and resource ('Returns only a URL to www Datenschutz') and explicitly bounds the scope by negating the privacy-policy body. This lets an agent distinguish it from sibling legal-page getters like get_legal and get_impressum without opening any schema.

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

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

Gives explicit when-to-use ('user asks for Datenschutz while on maps and you only need the link') and names alternatives ('Prefer www MCP get_datenschutz or get_legal for the corpus'). The only weakness is that the referenced 'www MCP get_datenschutz' is a same-named tool on a different server, which is ambiguous routing information rather than a clean sibling pointer.

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

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

Annotations already declare read-only safety, but the description adds substantial behavioral detail: missing files return `missing=true`, omitted `limit` triggers a ~30KB window with `nextOffset`, explicit limits keep the 1..10000 line window, and `summary` includes trailing `# MCP-META` with truncation metadata. These traits go well beyond the annotation and are directly useful for pagination and error handling.

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

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

The description is front-loaded with WHAT, USE, DOES NOT, and NEXT, so an agent can extract the key routing information quickly. It is dense and includes a long id list that duplicates the schema, but almost every clause carries operational meaning.

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

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

For this read-only discovery-file retrieval tool, the description covers the important edge cases: missing files, truncation, pagination via `nextOffset`, limit omission behavior, and aliases. An output schema exists, so return-value structure need not be explained further.

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 `which`, `limit`, and `offset`, including examples and default behavior. The description repeats the same `which` id list and limit behavior rather than adding new parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific retrieval target: a 1:1 mirror of a maps discovery file, with examples of the required `which` ids. It distinguishes itself from structured-search siblings by naming `find_by_keyword` / `find_by_serp` and by describing its alias relationship. The core phrase '1:1 mirror of a maps discovery file' is somewhat opaque, but the scope is still clear enough to separate it from siblings.

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

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

It gives explicit use cases ('USE for agent-ready catalogs and robots/sitemap') and names the alternative for structured search ('find_by_keyword / find_by_serp'). It also mentions known aliases. It does not state general prerequisites or when-not-to-use conditions beyond the structured-search alternative, so it falls short of a 5.

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

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

Annotations only declare readOnlyHint=true, so the description carries the rest; it discloses the returned payload shape (area card, maps_nav, neighbors, canonicalUrl) and the slug-first lookup precedence. However, since an output schema already exists, the RETURNS block largely restates structured data, and nothing is said about failure behaviour when a slug/plz/name matches nothing.

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

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

Front-loaded WHAT/RETURNS/USE/NEXT structure with no filler sentences. Slightly telegraphic jargon (Visitenkarte, MAPS-IL1/IL2) costs a little clarity but keeps it short.

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

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

For a read-only slug resolver with a full schema and an output schema, the definition covers purpose, parameters, return shape, and next steps. The main missing piece is what happens on a failed lookup and whether any of the three lookup keys is preferred when the caller supplies none.

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

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

Schema description coverage is 100% and the schema itself already documents PLZ ambiguity, name substring matching, and slug-first lookup order. The description's 'Lookup slug|plz|name' adds only a compact restatement, 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?

Names a specific verb+resource (returns the canonical map page URL for a Gebiet) and pins the scope to iframe/src embedding and Visitenkarte use. It partially differentiates from siblings by listing follow-up tools (get_geo_api, get_grenze, get_lage, get_service_area), though it never contrasts itself with the near neighbour resolve_maps_url.

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

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

Explicit 'USE for embedding or linking a Gebiet map' gives a clear activation condition, and the 'NEXT:' chain routes the agent onward. It lacks an explicit when-not rule (e.g. versus resolve_maps_url or find_by_gebiet), so it stops short of full alternative 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?

With only readOnlyHint in annotations, the description carries the extra burden and does add real context: no dispatch, no van claim, and it returns a URL only. Some of that is restated twice ('not a dispatch' vs 'DOES NOT dispatch technicians'), so it earns a 4 rather than a 5.

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

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

The WHAT/USE/DOES NOT structure is front-loaded and scannable, and each clause mostly earns its place. Minor redundancy between 'not a dispatch' and 'DOES NOT dispatch technicians' keeps it from a 5.

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

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

The tool is simple (one optional enum param, output schema present, readOnlyHint annotation), and the description covers what it returns, what it does not do, and which siblings to use instead. Nothing needed to call 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 coverage is 100% and the locale parameter already carries a detailed enum/default description, so the schema does the heavy lifting. The description only adds that locale selects the 'www URL language only', which is marginal value over the schema.

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

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

States a specific verb and resource: returns a URL to the www Notfall-Türöffnung page, explicitly narrowing scope to the link rather than an action or dispatch. It also distinguishes itself from siblings by noting it is not a dispatch and by naming alternate tools for alternate needs.

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 gives when to use it ('emergency lockout context on maps when you only need the link') and names concrete alternatives with conditions: get_contact or compose_tel_mobile for phone CTAs, www get_emergency for the full Notfall body. Nothing is left to inference.

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

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

Beyond the readOnlyHint=true annotation, it discloses that the tool does not return the answer body and that id/q are present only for www symmetry and are not answered here — non-obvious behavior an agent would otherwise get wrong. It stops short of describing the hand-off payload's shape or any latency/rate behavior, so not a full 5.

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

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

Short and front-loaded with what is returned before the routing advice. Minor waste: 'NEXT: www get_faq' largely repeats the earlier 'Prefer www MCP get_faq({id}|{q})' instruction, and the telegraphic fragments slightly hurt 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?

An output schema exists, so return values need not be described, and the annotations cover the safety profile. The description supplies the missing conceptual framing (this is a stub/hand-off, not an answer provider) plus the next step, leaving little an agent needs 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%, so the schema already carries the parameter docs. The description adds meaning beyond the schema by warning that the optional id/q parameters are inert on this endpoint ('not answered here'), which corrects the schema's misleading 'FAQ question search on www' wording.

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 and unusual purpose: it returns only a maps HTML hand-off to www /faq and explicitly does not return the FAQ answer body. It also differentiates itself from siblings by naming list_faq (hub) and www MCP get_faq (real answer). The phrasing is somewhat garbled ('Returns only a maps HTML hand-off to www /faq'), but the scope is ascertainable.

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 user asks one FAQ while on maps'), an explicit non-trigger alternative ('use list_faq for the hub'), and a preferred alternative with argument syntax ('Prefer www MCP get_faq({id}|{q}) for the real answer'). Routing is unambiguous.

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

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

Annotations only declare readOnlyHint=true, so the description carries the weight of explaining that the return is URL pointers rather than spatial data, and that the MCP payload is not the polygon. It also discloses the slug|plz|name lookup order. It stops short of noting auth/rate-limit traits of the public endpoints, keeping it below a 5.

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

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

The WHAT/RETURNS/USE/NEXT structure front-loads the essential fact and is scannable, though the inline URL templates and Sammel path listings are somewhat dense and partly redundant with the return description.

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

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

An output schema exists, so return values needn't be spelled out, yet the description still clarifies the URL-vs-data distinction and next-step routing that the schema cannot convey. It is complete enough for the agent to call it correctly, with only minor gaps around the public endpoints' access characteristics.

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

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

Schema coverage is 100%, so the schema already documents plz, name, and slug in detail. The description's 'Lookup slug|plz|name' only echoes that ordering and adds no format or semantics beyond the schema. Baseline 3 applies.

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

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

States a specific resource and outcome: public Geo-API URL pointers for one Einsatzgebiet, and explicitly says the payload is not the polygon. It distinguishes itself from sibling get_grenze by routing polygon-in-MCP access there, so an agent can tell the two apart without opening schemas.

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

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

'USE to fetch/open public JSON/GeoJSON' defines the trigger, and 'NEXT: get_grenze for polygon inside MCP, or GET grenze_api / punkt_api' names the explicit alternatives and when to prefer each. Little is left to inference.

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

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

With only readOnlyHint=true in annotations, the description carries most of the behavioral burden and does it well: it discloses that walkIn is always false, that the entity is a mobile locksmith rather than a counter, and that bookings are not supported. It stops short of noting e.g. caching or staleness of the pin data, but the core behavioral profile is clear.

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

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

Front-loaded with WHO/WHAT, RETURNS, USE, DOES NOT, NEXT labels, so an agent can extract the needed line quickly. Slightly verbose in enumerating return fields that the output schema already covers, and "The office is not a 53rd place" is an opaque aside.

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

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

A read-only single-parameter tool with an output schema is well covered: usage intent, exclusions, and routing are all present, so nothing critical is missing. The return-value listing is largely redundant given the output schema the agent already has.

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 single locale parameter is fully documented in the schema itself (German-only, ignored values, relation to www's list_locales). The description adds nothing about locale, 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?

States a specific resource (Gewerbesitz / registered office pin at maps.ikeytz.com/buero) and a distinct scope, immediately separating it from sibling location tools by noting it is a mobile locksmith operation with walkIn=false always. An agent can distinguish this from distance_to_office or list_service_areas without opening the schema.

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

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

Contains explicit use cases ("USE for NAP/schema or Footer iframe"), explicit exclusions ("DOES NOT accept walk-in customers or bookings"), and a NEXT list routing the agent to get_contact, distance_to_office, get_business_identity, and list_service_areas for the adjacent needs.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already covered, lowering the bar. The description adds the return field set (slug, name, geschichte) which is useful, but nothing about fallback behavior, error handling when no match is found, or how single-lookup first-match behaves (though schema covers some of this). Adequate but not rich.

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

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

Uses a WHAT/RETURNS/USE/NEXT structure that is front-loaded and scannable. Every clause is functional 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?

An output schema exists, so return values needn't be explained in depth; the description still summarizes them. With readOnlyHint annotations covering safety, 100% schema coverage, and explicit next-step routing, an agent has everything needed to call 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 coverage is 100% with detailed descriptions including lookup order (slug first), e.g. values, and multi-match behavior. The description only names the lookup keys ('slug|plz|name') without adding meaning beyond the schema. Baseline 3 is correct when 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?

States a specific verb (lookup/retrieve) and resource (Geschichte text for one Einsatzgebiet Visitenkarte), with the lookup key stated explicitly. Clearly distinguishable from siblings like get_lage and get_ai_page, which it explicitly names as next steps.

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

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

Explicitly states the use case ('USE for place history prose on the map page') and points to next tools (get_lage, get_ai_page). It doesn't state when NOT to use it or contrast with alternatives like get_wissen_entry or get_ai_page for prose content, which would be a 5.

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

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

Annotations only declare readOnlyHint=true, so the description carries most of the behavioral burden. It adds that the geometry is returned inline inside the MCP result and enumerates the response fields (hasPolygon, polygon, point, osmRelationId/osmWayId, via, grenze_api, punkt_api), which tells the agent how this differs from pointer-returning siblings. It omits auth/permission needs or rate limits, keeping it short of a 5.

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

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

Labeled WHAT/RETURNS/USE/NEXT structure is front-loaded and scannable, with each sentence carrying distinct information (purpose, output fields, usage, alternatives, follow-ups). No filler sentences.

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

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

An output schema exists, so return values need not be explained in prose, and the description still summarizes the shape. Combined with the explicit alternative tools and next steps, an agent has everything needed to select and 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 description coverage is 100%, and the schema already documents plz, name and slug including lookup precedence and examples. The description only restates 'Lookup slug|plz|name', adding no syntax or format detail beyond the schema, 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?

States a specific verb+resource: retrieves the OSM Gebietspolygon for one Einsatzgebiet as a GeoJSON FeatureCollection. It also explicitly names the sibling it is not (get_geo_api returns URL pointers, get_grenze_koordinaten returns the full embed blob), so an agent can distinguish it without opening other schemas.

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

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

'USE when the agent needs the boundary geometry' gives the triggering condition, and 'DOES NOT replace get_geo_api ... or get_grenze_koordinaten' supplies explicit exclusions with the reason for each. The NEXT line even suggests follow-on tools, leaving nothing to inference.

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

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

Annotations only declare readOnlyHint=true, so the description carries most of the load and does so reasonably: it discloses the exact returned field set, notes that separate GeoJSON exists at …/grenze and …/punkt, and points to Sammel endpoints. It confirms the read-only nature implicitly. It does not mention pagination, error behavior for unmatched lookups, or rate limits, which keeps it from a 5.

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

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

The WHAT/USE/DOES NOT/NEXT scaffolding is a helpful structure, but the content is a wall of comma-chained fragments packed with internal references (L-16, "slim", NAC, Sammel) and multiple HTTP URLs. The key action is not front-loaded — the reader must parse the embed endpoint and field list before reaching the actual when-to-use sentence.

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

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

An output schema exists, so return values need not be explained, yet the description still enumerates payload fields, which makes it largely complete for a 3-param, zero-required lookup tool. Coverage of the three lookup modes, precedence, and sibling routing is present. Only edge behavior (no match, ambiguous name matches) is unaddressed.

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

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

Schema coverage is 100% and every parameter's description already covers lookup semantics, precedence (slug first), and PLZ collisions. The description adds only the compressed "Lookup slug|plz|name" restatement, which duplicates rather than extends the schema. Baseline 3 is correct when 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?

The description states that the tool returns the full public Ort-Embed JSON for one Einsatzgebiet, enumerating concrete payload fields (phone/NAP, style, point, featureCollection, OSM ids, embed paths, iframe). It also distinguishes itself from get_grenze (polygon-only) and get_geo_api (URL pointers). It falls short of a 5 because the name implies coordinates while the payload is a full embed object, and the purpose statement is wrapped around HTTP-path and internal-code jargon (L-16) that muddies the core claim.

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 when the agent needs coordinates+boundary+NAP in one MCP call" gives a clear trigger, and "DOES NOT replace slim get_grenze (polygon-only) or get_geo_api (URL pointers)" gives explicit exclusions with named alternatives. It stops short of 5 because the trailing "NEXT: get_grenze, get_contact, get_embed_map" list is unexplained and leaves the reader inferring why get_contact is a follow-up.

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=true already covers the safety profile, and the description adds real behavioral context: the payload shape (title/h1 + 52 Gebiet links), the scope boundary (no www prices), and the required empty call. The output schema carries the return structure, so nothing material is missing.

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?

Telegraphic WHAT/USE/NEXT structure is front-loaded and every fragment earns its place, but the keyword-caps style and the redundant "Call with {}" (already in the schema) cost a point against a clean 5.

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

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

For a no-arg, read-only hub with a rich output schema and annotation coverage, the description supplies the entry-point role, content summary, an exclusion, and successor tools. Complete enough to invoke correctly, with only the sibling-routing comparison left implicit.

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?

Zero parameters, so the baseline is 4; the schema itself documents the empty-object contract, and "Call with {}" reinforces it without adding new meaning. Nothing further is needed for a no-arg tool.

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 resource (maps hub card at a given URL) and its exact contents — title/h1 plus 52 Gebiet links — and explicitly distinguishes it from a single Visitenkarte. An agent can tell this apart from sibling list/find tools from the description alone.

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

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

"USE as the maps landing overview" gives a clear entry-point context, and "NEXT: get_service_area, list_service_areas" routes the agent onward. "DOES NOT include www prices" adds a useful exclusion, but it never states when a find_by_* tool should be preferred over this hub.

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 safe read behavior. The description adds useful context beyond annotations: the source file path (/llms-impressum-kontakt.txt), the map-specific imprint purpose, and the presence of optional offset/limit paging. It does not discuss auth or return shape, but those are covered by annotations/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 extremely compact and front-loaded using WHAT/USE/NEXT labels. Every clause contributes routing information, with no redundant or filler content.

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

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

For a read-only static-text retrieval tool with full schema coverage, readOnlyHint annotation, and an output schema, the description supplies the needed source, purpose, and alternative endpoints. Nothing essential for correct invocation 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 limit and offset are fully documented in the schema. The description only notes 'Optional offset/limit' and adds no syntax or format detail beyond what structured fields already provide. Baseline 3 is appropriate when the schema carries 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 and resource: 'Impressum/Kontakt text from maps /llms-impressum-kontakt.txt.' It distinguishes the tool from nearby siblings by naming get_contact, get_business_identity, and the www /impressum HTML variant.

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

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

It gives explicit usage context ('USE for NAP/legal imprint on maps') and names alternatives ('NEXT: get_contact, get_business_identity; www /impressum for HTML'), which tells an agent when to select this tool versus adjacent ones.

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=true already flags a safe read, and the description adds real value beyond it: it discloses that the tool does NOT return totalEur and instead returns an html link, and that line items are computed elsewhere. This candid limitation disclosure is exactly the behavioral context an agent needs, though it omits details like response shape or pagination.

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

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

It is short and front-loads the WHAT, then the DOES NOT, then NEXT. The abbreviated, telegraphic style is dense but roughly earns its words; some phrasing ('maps accepts … for symmetry') is a little cryptic but not wasteful.

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

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

An output schema exists, so return values need not be specified, yet the description still usefully clarifies what is NOT returned and where to get it. Combined with the routing hints, an agent has enough to call it correctly, though a clearer statement of the actual pointer payload would complete it.

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

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

Schema coverage is 100%, so the baseline is 3; the description nonetheless adds interpretive value by explaining that situationKey/whenKey/breakdown are accepted 'for symmetry' on maps and do not drive computation. This clarifies that these params are effectively inert for this endpoint, which the schema alone does not make obvious.

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

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

The description clearly states this is a 'www pointer only' that returns an html link to /preise rather than computed line items, directly countering the misleading name/title. It distinguishes itself from the www sibling that actually computes line items. It is specific about verb, resource, and scope, though the telegraphic phrasing makes it slightly harder to parse than ideal.

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: @ikeytz/mcp get_invoice_line_items' line explicitly routes the agent to the www tool that actually returns totals, and it names get_ort_datetime for the Berlin clock/whenKey use case. The condition selecting the www alternative is stated ('invoice line items are computed on www MCP'). It stops short of an explicit 'use this when…' statement for the pointer itself, so not a full 5.

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