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 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 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?

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 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 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?

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 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 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?

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?

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.

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

Annotations already declare readOnlyHint=true, so the safety profile is covered and the description's marginal contribution is the negative disclosure 'DOES NOT return polygons' plus the promised return fields (slug, name, lage). It does not describe empty-result/error behavior or rate limits, which would be the remaining behavioral gaps for a lookup tool.

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

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

Capsule format (WHAT / RETURNS / USE / DOES NOT) is maximally front-loaded: the one-line WHAT comes first, routing second, exclusions last. Every clause carries new information; nothing is padding.

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

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

With an output schema present, the description needn't enumerate return values, and it correctly focuses on lookup keys, routing, and scope limits. It is nearly complete, missing only what an agent should expect on no-match or when multiple Gebiete share a PLZ, which is left to the schema.

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

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

Schema description coverage is 100%, so the schema already explains each of slug/plz/name, including the 'slug first' lookup order and the find_by_plz escalation. The description's 'Lookup slug|plz|name' restates rather than extends that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Returns Lage (location description) prose for one Einsatzgebiet Visitenkarte') and pins the lookup keys. It goes further by naming what it does not do ('DOES NOT return polygons') and naming the siblings it is not (get_geschichte, get_service_area), so an agent can separate it from adjacent tools immediately.

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

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

The USE line states the positive condition ('human-readable geography prose') and then gives explicit routing rules: prefer get_geschichte for place history, prefer get_service_area for the full point card/embed. That is a when-to-use plus two named alternatives, which is the strongest form of guidance.

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

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

With readOnlyHint=true, the safety profile is already covered. The description adds behavioral nuance: maps corpus returns text via discovery for some docs, while www docs return only a URL pointer and not the HTML body. That's useful beyond annotations, but the phrasing is opaque and could mislead about return format.

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's dense and telegraphic — 'WHAT', 'USE', 'DOES NOT', 'NEXT' — packing multiple concepts into fragments that require decoding. Sentences don't flow and key information (what actually gets returned) is obscured. It's short in character count but not clear or 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 router with 4 params, one required enum, and an output schema, the description covers the main split between maps text and www URL pointer. But it doesn't explain what the output actually contains or when the offset/limit pagination applies. Given the tool is a dispatcher, the routing logic should be clearer.

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 parameter semantics are already well documented. The description repeats the doc enum grouping but doesn't add format examples or clarify offset/limit beyond what the schema states. Baseline 3 is appropriate.

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

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

The description calls itself a 'Legal doc router' and explains the doc enum mapping, which clarifies purpose, but the actual operation — what is returned, whether it's text, a URL, or a pointer — is muddled by jargon like 'maps text via discovery' and 'www URL pointer only'. Sibling tools like get_impressum and get_urheberrecht suggest this is a generic legal doc fetch, yet the description doesn't clearly state it returns citations or content.

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 says 'USE for citations' and names NEXT shortcuts (get_urheberrecht / get_impressum), implying when to prefer those, but it doesn't specify when to use get_legal versus the many specific sibling tools. The 'NEXT' is a stack trace of intended follow-ups, not a clean when-to-use 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 a genuine behavioral boundary beyond that ('DOES NOT fetch discovery file bodies'), clarifying this is a metadata/bookmark lookup rather than a content fetch. It stops short of describing response shape or pagination, but the output schema covers returns.

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?

Dense but front-loaded with WHAT/USE/DOES-NOT scaffolding; every clause carries routing or boundary information. 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?

For a simple read-only URL-list tool with a full output schema and 100% schema coverage on the one parameter, the description supplies what structured fields cannot: the contents list, the alternatives, and the non-fetching boundary. Nothing an agent needs 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 enum is thoroughly documented in the schema (including the German-only constraint and the www multi-locale alternative). The description adds nothing about the locale parameter, so the baseline 3 applies since the schema fully carries this 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 and resource ('Returns the maps machine bookmark set of discovery URLs') and enumerates the concrete contents (hub, mcp, server-card, llms, etc.). It explicitly differentiates itself from the nearest siblings get_discovery and get_llms_txt, so an agent can route 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 to open known well-known endpoints by URL' gives the triggering condition, and it names two alternatives with the exact case for each (get_discovery for file contents/line windows, get_llms_txt for the llms index body). The closing 'DOES NOT fetch discovery file bodies' adds an explicit exclusion.

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 genuinely useful behavior beyond the annotations: the return is a hand-off, not the terms text, and 'DOES NOT invent clauses' warns against fabricating content. It does not discuss failure modes or hand-off resolution, 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?

Three tight sentences, front-loaded with scope, then usage, then next steps; nothing is wasted. The telegraphic ALL-CAPS USE/DOES NOT/NEXT markers read as machine-oriented cues rather than prose, which costs a little polish but not clarity.

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 no explanation, and the description wisely states only the one thing the output schema can't convey to a caller — that the terms body is not included. For a zero-param, read-only hand-off tool, this is nearly complete; only failure/fallback behavior 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?

The tool takes zero parameters, so the schema-plus-description baseline is 4. There is nothing to add — the empty schema and the no-arguments note fully cover the parameter surface.

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 maps HTML hand-off to www Nutzungsbedingungen' and explicitly adds the negative scope 'Does not return the terms body.' That negative framing is what separates it from content-returning siblings like get_agb or get_legal. Slightly jargon-y ('hand-off') but the scope is unambiguous.

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

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

Explicitly says 'USE when the user asks for Nutzungsbedingungen on maps; prefer www MCP for the corpus,' naming both the trigger and the preferred alternative. It also chains forward with 'NEXT: www get_nutzungsbedingungen / get_legal,' so the agent knows what to call when this hand-off is not what it wants.

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 usefully adds behavior: the default scope when all params are omitted ('all 52 places with the same clock') and a negative capability statement ('DOES NOT return euro amounts'). It also enumerates the returned fields, going beyond the read-only hint. It does not discuss error behavior or rate limits, but an output schema exists to carry the return shape.

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

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

It is front-loaded with WHAT/RETURNS/USE/DOES NOT/NEXT labels, so the structure is scannable and nothing is padded. However, the telegraphic fragments and internal jargon ('whenKey', 'www invoicing', '@ikeytz/mcp') trade clarity for brevity, so conciseness comes at a readability cost rather than being cleanly efficient.

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

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

For a read-only lookup with three optional params and an existing output schema, the description supplies the essentials: purpose, default scope, negative boundary, and next-step tools. An agent can call it correctly without opening the schema. It stops short of explaining how 'stand'/'whenKey' values should be consumed downstream, leaving a small gap.

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

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

Schema description coverage is already 100%, so the baseline is 3; the description adds genuine value by explaining the no-parameter default ('omit = all 52 places with the same clock') and by relating the three optional inputs to the sibling get_service_area. It correctly mirrors the slug/plz/name optionality rather than contradicting it.

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

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

The description states a specific verb+resource: it returns the Europe/Berlin wall-clock time to the second for a location ('Ort'), including the exact output format and the fields returned. It partially differentiates from siblings by pointing to get_service_area for the same slug/plz/name inputs and to get_invoice_line_items/get_prices as the follow-on tools. The phrasing is telegraphic ('for pricing whenKey context'), which slightly muddies an otherwise clear purpose.

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

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

It gives explicit sequencing ('USE before quoting via www get_invoice_line_items') and an explicit exclusion ('DOES NOT return euro amounts'), plus NEXT-step alternatives (get_invoice_line_items or get_prices). That covers when-to-use, when-not, and alternatives, but the routing between the two named alternatives is not distinguished, and the internal shorthand reduces confidence.

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