ikeytz - Schlüsseldienst Ludwigsburg

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

Even with readOnlyHint=true already covering side-effect safety, the description adds valuable behavioral context: it does not actually send email, omitting the option yields a populated beratung template rather than a bare mailto, and the partner mailbox is not the hardcoded href. These details go beyond annotations and prevent misuse.

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?

Compact and front-loaded: the WHAT sentence is followed only by essential caveats such as the default call behavior, no-send guarantee, and partner mailbox location. Every sentence carries a distinct fact with no filler.

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

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

For a tool with zero required parameters, a fully described enum, an output schema, and a readOnly annotation, the description covers invocation, default behavior, side-effect boundary, and the likely partner-mailbox confusion. Nothing needed 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?

The single optional enum is fully described in the schema, so the baseline is 3. The description adds useful business meaning by tying option to a contactOption of one of the 10 end-invoices, cylinder_mount, or beratung and reaffirms the omit-default. However, the mapping leaves three enum values (zugefallen, abgeschlossen, zylinder) unmentioned, so it is not exhaustive.

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 WHAT: it produces a mailto:info@ikeytz.com link using the same subject+body prefab as compose_whatsapp. This names the exact target resource and output channel, and clearly distinguishes it from the compose_tel_* and compose_whatsapp 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 concrete call guidance ({} maps to the beratung template, not an empty mailbox), states that email is not sent, and redirects partner-mailbox needs to get_partner_info.partnerEmail. It does not explicitly spell out when to choose this over the WhatsApp or phone compose tools, but the exclusions and references make selection fairly clear.

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

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

The readOnlyHint annotation already establishes that this is a safe read-only operation. The description adds the no-argument calling convention and the output type (tel: href), but it does not go beyond that with edge cases, determinism, or side-effect details. That is acceptable for a simple no-arg tool, but not richly transparent.

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

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

The description is extremely concise and front-loaded: it states the output, the calling convention, and the key alternative in one compact line. Every element earns its place, and there is no redundant prose.

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

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

For a zero-parameter, read-only tool with an output schema, this description is complete. It explains what the tool returns, how to call it, and when to choose a sibling instead. No critical information needed by an agent to invoke it correctly is missing.

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

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

There are zero parameters, and the schema description already fully covers the calling convention. The description reinforces this with 'Call with {}', which is helpful but does not add much beyond the schema. The zero-parameter baseline of 4 applies.

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

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

The description clearly states that the tool produces a tel: href for the landline (Festnetz), which is a specific output and resource. It also distinguishes itself from compose_tel_mobile by explicitly naming that sibling, so an agent can separate the two without inspecting schemas.

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

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

The description gives an explicit routing rule: mobile and 24h emergency use compose_tel_mobile instead. This tells the agent when not to use this tool and which alternative to select, which is exactly the kind of usage guidance needed.

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

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

Annotations declare readOnlyHint=true, and the description goes further by explaining that the tool only returns href and canonicalUrl values and does not actually place a call. The instruction 'do not pretend the call happened' adds practical behavioral transparency beyond the annotation.

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

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

The description is compact and structured with clear WHAT/RETURNS labels, making it easy to parse. Every sentence adds value: the purpose, the output, the behavioral caution, and the sibling distinction are all included without fluff.

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

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

Given the zero-parameter signature, presence of an output schema, and readOnly annotation, the description covers everything needed: it names the output fields, explains the result is a link to display, and identifies the related landline tool. There are no significant gaps.

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

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

The tool has zero parameters and the schema description already documents that no arguments are needed and extra keys are ignored. The description reinforces this by saying 'Call with {}', so no additional parameter explanation is required.

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

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

The description clearly states the tool composes a tel: href for the 24/7 mobile (Handy), specifying both the verb and the resource. It differentiates from the landline sibling by explicitly naming compose_tel_landline as the alternative for landline.

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

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

The description gives explicit context: use this tool to generate the mobile/Handy tel: link, and use compose_tel_landline for landline. It also instructs the agent to show the result to the user rather than pretending a call happened, providing clear behavioral 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?

Beyond readOnlyHint=true, the description reveals key behaviors: building a URL does not send a message, omitted/unknown option defaults to beratung, and deprecated aliases set ambiguous=true. It also disambiguates the 49 € value as cylinder mount rather than a night invoice. No contradiction with annotations.

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

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

The description is compact and front-loads the core function in the first sentence, then packs defaults and deprecations efficiently. The pipe-delimited option list is dense but every sentence earns its place, though some phrasing is telegraphic.

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 one optional parameter, enum schema, output schema, and readOnly annotation, the description covers default behavior, deprecated values, source of options, and the non-sending behavior. Nothing essential for correct invocation is missing; it even references list_whatsapp_options for additional options.

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

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

The schema already documents the option enum and its description at 100% coverage. The description adds value by explaining the default fallback for omitted/unknown values and the deprecated alias mapping, which the schema does not state. Base 3 plus one for extra 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 and resource: 'Build a https://wa.me/… URL'. Explicitly narrows scope with 'Does not send WhatsApp' and names the list tool alternative, distinguishing it from compose_mailto/compose_tel 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?

Tells the agent where valid option values come from ('contactOption from get_prices.composition.endInvoices or get_invoice_line_items.contactOption'), warns against deprecated aliases ('do not use them'), and points to list_whatsapp_options for listing. It does not explicitly contrast with the other compose_* tools, but the channel-specific name plus these instructions provide adequate guidance.

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

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

Annotations only provide readOnlyHint=true, so the description carries the behavioral burden. It discloses case-insensitive matching, the exact data source URL, default and maximum limits, empty-q behavior, the raw TSV-like return rows, and the important caveat that locale does not filter the file. This is far more than the annotation alone provides.

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

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

The description is tightly packed with labeled sections (WHAT, REQUIRED, DEFAULT, RETURNS, USE, NEXT) and no filler. Every sentence contributes either to selection, invocation, or follow-up. The front-loaded WHAT and REQUIRED statements make the core purpose immediately visible.

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 source is fully identified, required and optional parameters are covered, locale limitations are clarified, return shape is mentioned, an output schema exists, and the natural next-step tool is provided. For a read-only search tool, no essential decision or invocation information 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%, which sets the baseline at 3, but the description adds meaningful semantics beyond the schema: case-insensitive matching, the fact that q matches against the whole keyword line, empty-q handling, and the explicit note that locale does not filter the file. These details help an agent understand the parameters in context.

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 operation: substring search over a named keyword file (llms-keywords.txt) mapping phrases to URLs. It also gives the intended use ('map a user phrase to URLs') and names the follow-up sibling (get_ai_page), making it easy for an agent to distinguish from the adjacent get/list tools.

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

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

The description explicitly says when to use the tool ('USE to map a user phrase to URLs') and provides a clear next step ('NEXT: get_ai_page on a returned www path'). It does not explicitly state when not to use it or list alternative tools, so it falls just short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds behavioral context by calling this a 'pointer' rather than a content endpoint, implying the tool returns a reference/location rather than the full page. This is useful beyond the annotation and does not contradict it, though it could be slightly more explicit about output behavior. Given the low bar set by the readOnlyHint annotation, this 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?

The description is extremely compact, using labeled 'WHAT' and 'NEXT' segments to front-load the core purpose and follow-up action. Every sentence contributes either purpose, routing, or workflow guidance with no filler.

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

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

For a simple, read-only pointer tool with one optional parameter and a full schema description plus an output schema, the description covers the essential aspects: what it points to, which sibling to use for alternative data, and what to call next. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, and the locale parameter is thoroughly documented in the input schema, including defaults, URL behavior, and non-applicability to German legal names. The tool description adds no additional parameter-level detail, but none is needed because the schema already carries that weight.

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

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

The description states a specific verb and resource: it is a 'Pointer to /ueber-uns' for about/owner information. It also explicitly differentiates itself from get_business_identity, which is the tool for NAP facts, making its purpose distinct among many similar get_* 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?

The description gives an explicit alternative condition: 'For NAP facts prefer get_business_identity.' It also suggests a next step, get_ai_page, which clarifies the intended workflow and when this tool should be used as a pointer rather than a content fetcher.

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

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

Annotations already establish readOnlyHint=true, but the description adds real behavior beyond that: the summary is capped at the first 4000 chars with a truncated flag, path=/ maps to index.txt, and /review lacks an HTML-parity footer. These are non-obvious traits, though response details are partly covered by the existing 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?

Uses a WHAT/USE/NEXT structure that is front-loaded and dense with routing value. It is somewhat telegraphic and run-on, but nearly every clause carries information an agent needs.

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 need not explain return values, and it still documents URL derivation, truncation behavior, and sibling routing. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% (baseline 3), but the description adds value beyond the schema by explaining the derived file naming (path=/ → index.txt, else path minus leading slash + .txt) and the locale-in-path override, which the schema does not state.

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 (fetches one marketing page's HTML-parity fulltext) and gives the exact URL construction rule. It explicitly distinguishes itself from siblings get_ai_txt and get_serp_snippet so an agent can tell them apart 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?

The USE clause names when to use it (page body text) and when not to, naming the two alternatives (get_ai_txt for /.well-known/ai.txt policy, get_serp_snippet for meta only). The NEXT clause reinforces routing to the correct sibling.

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

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

With readOnlyHint already declaring a safe read, the description still adds real context: it summarizes the actual policy semantics (ai-input yes with attribution, ai-train=no, contact), notes paging behavior for large files, and states the negative-scope constraint "DOES NOT return page bodies", which is the key mis-selection risk for the similarly named get_ai_page.

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 the purpose first and the routing advice second; dense but every clause earns its place. Slightly run-on with fragments ("Optional offset/limit page large files"), but 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-shape detail is not required, and the description covers purpose, exclusions, alternatives and paging. Fully callable as written; only the parameter behavior is deferred entirely 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% and the schema already documents offset/limit, clamping to 1..10000, nextOffset paging and the 0-based line indexing. The description only points at the schema ("see parameters / nextOffset in schema"), adding no semantics of its own, 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 (Fetch) and resource (/.well-known/ai.txt), defines its content (site-wide crawl/training policy with the ai-input/ai-train/contact fields), and names the siblings it is not — get_ai_page and get_discovery — so an agent can distinguish it 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?

Gives explicit when-to-use ("policy before quoting") and explicit alternatives with the condition that selects them: prefer this over get_ai_page for per-URL fulltext, and over get_discovery unless a generic file window is needed. 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?

Annotations already declare readOnlyHint=true, and the description adds useful behavioral context by stating that it returns only slug + canonicalUrl, not fulltext content. It also sets expectations by directing the agent to get_ai_page for fulltext, which clarifies the tool's limited scope beyond what annotations convey.

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 highly concise and well-structured: WHAT, REQUIRED, RETURNS, USE, NEXT. Every sentence delivers distinct value, and the most important prerequisite is front-loaded.

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

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

For a simple read-only tool with an output schema and fully described parameters, the description covers purpose, prerequisite, use case, and follow-up actions. Nothing critical is missing for an agent to correctly select and invoke the tool.

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

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

Schema description coverage is 100%, with detailed parameter descriptions including examples and a 'Not an Ort slug' note. The description adds marginal reinforcement ('REQUIRED slug from list_auswahl') but doesn't substantially expand beyond what the schema already provides, 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 resource ('One Auswahl situation page') and the exact return value ('slug + canonicalUrl'), making it clear what the tool does. It is distinguishable from sibling tools by requiring a slug from list_auswahl and focusing on lockout/key situations, which is unique among the listed 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?

The description explicitly says 'USE after the user described a lockout/key situation' and instructs that the slug must come from list_auswahl. It also provides concrete next steps (get_ai_page for fulltext, get_invoice_line_items for euro), giving the agent clear routing guidance versus alternatives.

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

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

Annotations only provide readOnlyHint=true; the description adds substantial behavioral context: no updates accepted, walkIn is always false, canonicalUrl value, and the limitation that it cannot prove licenses. These are exactly the non-obvious traits an agent needs before invoking.

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 dense but highly structured with WHO/RETURNS/USE/DOES NOT/NEXT markers. Every segment earns its place, and critical facts 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 single-optional-parameter read-only tool with a rich schema and output schema, this description is complete: it covers purpose, return highlights, use cases, exclusions, and sibling routing. Nothing essential is missing.

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

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

Schema coverage is 100% and the sole parameter (locale) is thoroughly described in the schema, so the description is not required to add parameter meaning. It does not meaningfully enhance the locale semantics; baseline 3 is appropriate.

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

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

The description states exactly what the tool returns — legal/trade identity and NAP facts — and anchors it with concrete use cases ('impressum-grade facts', schema.org LocalBusiness fields). It also distinguishes itself from siblings by naming get_legal, get_contact, and get_geo_office as related tools.

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

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

Explicit USE guidance tells the agent when to call this tool, and DOES NOT states limitations (cannot prove licenses, does not accept updates, walkIn is always false — do not send customers to the office). It also provides NEXT tool pointers, which is ideal routing behavior.

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

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

The readOnlyHint annotation already signals read-only behavior, and the description adds meaningful context: the data is public, the tool has no form-submission side effect, and the agent must not claim it did. This prevents both misuse and hallucinated success.

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

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

The WHAT/USE/NEXT structure is compact, scannable, and every clause carries value: the returned object, the exclusion, the intended use, and follow-up tools. There is no filler or redundancy.

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

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

For a one-optional-parameter read-only tool with an output schema, the description covers the essential context: what is returned, what is not done, when to use it, and what to do next. 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 single optional locale parameter is already fully documented in the schema with defaults, URL-prefix behavior, and scope limitations. The description does not add parameter-level detail, but it does not need to because the schema is complete.

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 exactly what is returned: a public contact object containing phones, fax, email, and office address. It also distinguishes the tool from the website contact form and from the compose/list siblings, so an agent can tell it apart without inspecting schemas.

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

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

It gives an explicit use case ('USE to give the user a number'), an explicit non-use ('DOES NOT submit the website contact form and must not claim it did'), and lists relevant NEXT alternatives. This is clear routing guidance rather than a generic statement.

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

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

Beyond the readOnlyHint annotation, the description discloses the line-window behavior, pagination via offset/limit and nextOffset, the trailing # MCP-META summary format, size warnings for sitemap (~9076 URLs) and llms-keywords (~50MB), and the ai-train=no policy note. This adds rich behavioral context beyond the annotation.

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

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

The description is dense and long, but every piece earns its place: the WHAT statement, ID list, pagination mechanics, size warnings, and alternative routing. It is front-loaded with the core action and requirement. It could be broken into clearer sections, but it avoids fluff.

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

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

For a tool with 3 parameters, an output schema, and many siblings, the description covers all necessary operational aspects: accepted IDs, paging, file-size handling, unknown ID fallback, and explicit routing to dedicated tools. 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 file-specific parameter guidance: for sitemap.txt omit limit to get full list, for llms-keywords prefer a window, and explains how offset/limit and nextOffset combine for paging. This meaningfully supplements the schema definitions.

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

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

The description explicitly states it fetches a public discovery file and returns a line window, lists the accepted IDs/aliases, and distinguishes itself from dedicated sibling tools by saying 'Prefer dedicated get_llms_txt ... when you know the file.' This gives a clear verb, resource, and differentiation.

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

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

Provides explicit when-to-use vs alternatives: 'Prefer dedicated get_llms_txt / get_llms_jsonld / get_llms_serp_txt / get_sitemap_txt / get_llms_mcp_server when you know the file.' Also states fallback behavior for unknown IDs ('Unknown which → unknown_discovery'), leaving no ambiguity about selection.

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 value beyond that by stating the negative behaviors (no dispatch, no booking) and by disclosing that the summary includes the mobile number and the locale-prefixed canonicalUrl. It stops short of describing pagination or full response structure, but with readOnlyHint present this is rich for a pointer tool.

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

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

The WHAT/USE/DOES NOT/NEXT structure is front-loaded and scannable, and every clause carries routing or behavioral information. No filler or repetition of the tool name.

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 explained, and the description still covers purpose, when-to-use, alternatives, exclusions, and next steps. Nothing an agent needs to call this one-parameter read tool correctly is missing.

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

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

Schema description coverage is 100% and the single locale parameter is fully documented in the schema (enum values, default, prefix behavior, scope limits). The description only hints at locale via 'locale-prefixed', so it adds little 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 verb and resource ('Returns the 24h Notfall-Türöffnung page pointer') and even names the canonicalUrl path, so the agent knows exactly what comes back. It differentiates from siblings by naming get_contact and compose_tel_mobile as alternatives, making it distinguishable 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?

Explicit 'USE when the user needs emergency door-opening contact on www', plus named alternatives ('Prefer get_contact for general NAP; prefer compose_tel_mobile to dial') and exclusions ('DOES NOT dispatch a technician or take a booking'). The NEXT chaining hint (list_whatsapp_options then compose_whatsapp) gives a complete routing picture.

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?

Discloses lookup precedence, fallback matching behavior, and the missing-result signal faq_not_found. With readOnlyHint already set, the description adds useful behavioral context rather than repeating 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?

Very compact and front-loaded with WHAT and lookup rules. Every sentence carries routing or behavior information, with no filler.

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

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

Complete for a read-only FAQ lookup: lookup strategy, error behavior, alternative tool routing, and id source are all covered. The input schema handles parameter details and the output schema handles return shape.

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

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

Schema coverage is 100% and the schema already explains q, id, and locale in detail. The description mostly reinforces the id-before-q priority already stated in the schema, so it adds little new parameter meaning.

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

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

States the exact resource and operation: retrieving one FAQ Q+A entry, with examples of topics. It also distinguishes itself from siblings by saying it is not a calculator and pointing to get_invoice_line_items and list_faq.

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 lookup behavior: exact id first, else substring search on q. It also names the alternative tool for euro amounts and tells the agent to prefer ids from list_faq, making when-to-use and when-not-to-use clear.

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

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

Annotations already mark readOnlyHint=true, and the description adds meaningful behavioral context beyond that: it returns a specific fixed office, walkIn=false, external GBP click only, and embed/API URLs. It also explicitly warns that this is not a shop or a service-area map, which prevents misinvocation. No contradiction with annotations.

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

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

The description is front-loaded with WHAT and RETURNS, then boundaries, then next steps. It is dense and slightly noisy with all-caps labels and inline URLs, but every sentence earns its place and no information is wasted.

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

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

Given an output schema and a readOnlyHint annotation, the description still adds essential context: the exact address, non-shop status, service-area exclusion, external-click behavior, and follow-up tool suggestions. An agent has everything needed to decide when and how to invoke it correctly.

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

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

There is only one parameter, locale, and the input schema documents it comprehensively (enum values, default, URL prefix behavior, exclusions). The description does not need to add parameter detail; baseline 3 applies because the schema does the heavy lifting.

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

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

The description states a specific verb and resource: it returns the registered office (Firmensitz) for a fixed SITE.geo address. It clearly distinguishes itself from shop and service-area place maps, even naming sibling alternatives. An agent can immediately tell this tool apart from related get/list tools.

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

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

The description gives explicit when-to-use guidance: use this for the registered office, never send customers to walk in, and use list_service_areas / get_service_area for Ort slugs instead. It also names likely next tools (get_contact, get_legal). This gives the agent clear routing and exclusion criteria.

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

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

With readOnlyHint=true already present, the description still adds substantial behavioral context: exact classification logic, alias mapping, breakdown behavior, and return shape (totalEur + composition + contactOption). It also clarifies that it is not a booking or PDF and does not include VAT, going well beyond the annotation.

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

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

The description is dense but every clause carries a domain rule necessary for correct invocation. It is front-loaded with WHAT and exclusions, then flows through the classification, timing, special cases, output, and next steps. The structured labels keep it scannable despite its length.

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

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

Given the intricate pricing logic and 100% schema coverage, the description covers the full decision tree, edge cases, aliases, and downstream tools. The presence of an output schema handles return-value specification, so nothing an agent needs to call this 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%, but the description adds crucial meaning not inferable from the schema: situationKey aliases (zugefallen→opening_slam), the special rule that night is not +49 (49 only for cylinder_mount), and the exact effect of breakdown=true. This enriches the bare parameter definitions.

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

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

The description opens with 'Computes ONE of the 10 end-invoices (or the 49 € mount add-on)' and immediately excludes misconceptions with 'NOT a booking, NOT a PDF.' This gives a specific verb and resource and differentiates it from sibling tools like compose_whatsapp and get_prices.

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

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

The description provides an explicit decision procedure: classify via get_prices.composition.routes, get whenKey from get_ort_datetime, handle aliases, and then proceed to compose_whatsapp or compose_mailto. It also states exclusions like 'Night/WE/holiday is NOT +49' and 'Do not add 49 on top of pkg_key_*', leaving no ambiguity about when and how to use it.

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

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

Annotations already mark the operation readOnlyHint=true, and the description adds meaningful behavioral context: www /mcp never calls maps /mcp, proxy=false, and /it is not Italian. These details go beyond the structured fields and help the agent avoid misconceptions.

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 structure front-loads the core purpose and keeps the description dense. A few phrases are cryptic or use ellipses ('maps={...}'), and some details are niche, but overall every sentence carries distinct 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?

Given the simple single-optional-parameter schema and presence of an output schema, the description is complete enough. It covers the page's role, the two endpoints, the distinction from the hub tool, and the non-HTTP CLI channel, so an agent has sufficient context to invoke it correctly.

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

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

The only parameter, locale, is fully documented in the input schema with an enum, default value, and detailed explanation of URL prefix behavior. Schema coverage is 100%, so the description does not need to add parameter semantics; the baseline 3 applies.

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

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

The description names a specific resource ('HTML page /it') and explains it documents two MCP machines (website/www and maps). It also distinguishes itself from the sibling get_mcp_hub by explicitly pointing to '/mcp-hub (get_mcp_hub)', so an agent can tell this tool apart.

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

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

It explicitly says 'USE to tell an agent there are TWO endpoints (www vs maps)' and clarifies the hub HTML belongs to get_mcp_hub, not this tool. It also rules out the CLI npm channel as a separate third channel, giving clear selection guidance.

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

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

Annotations already mark the operation read-only. The description adds valuable behavior beyond that: unknown docs produce ok=false and a hint, the return includes doc + canonicalUrl rather than full content, and language precedence is stated. It could go further on details like auth or rate limits, but those are not critical here.

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

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

The description is compact, telegraphic, and front-loaded. Every clause earns its place: scope, required parameter, edge-case response, return value, alternatives, and language caveat are packed into a few short lines with no filler.

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

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

For a read-only pointer tool with a full schema and output schema, the description covers the essential selection and invocation information: what it returns, what it does not return, how to get full text, and how invalid input behaves. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that doc is required and used as a path slug, and it adds error-behavior context for invalid docs, but it does not add much semantic value beyond what the schema already documents.

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

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

Description states a specific verb and resource: 'Pointer to one legal HTML page.' It explicitly distinguishes itself from full-text tools by directing callers to get_ai_page and get_discovery, so the tool's scope is immediately clear to an agent.

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: this tool returns the pointer/canonical URL, while full text requires get_ai_page, and the copyright corpus requires get_discovery. It also specifies the unknown-doc error shape and the language/binding caveat, leaving little ambiguity about selection.

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=true annotation already covers the safety profile, so the description's burden is lower. It adds useful negative scope ('DOES NOT list MCP tools') and describes the tool as a pointer to an HTML list, though it does not detail pagination, rate limits, or return structure (output schema handles the latter).

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 a WHAT clause and then uses USE, PREFER, DOES NOT, and NEXT labels to separate routing, exclusion, and follow-up guidance. Every sentence contributes directly; 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?

Given a read-only pointer tool with an output schema and one fully documented enum parameter, the description supplies everything an agent needs: content scope, exclusions, sibling alternatives, and next actions. It does not need to explain return values because the output schema exists.

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 fully documented with enum values and URL-prefix behavior. The tool description adds no additional parameter meaning, so the baseline of 3 applies when the schema does all semantic 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?

The description states a specific resource (/links) and enumerates the content categories it covers (local directories, city sites, HWK, Webmail shortcut). It explicitly distinguishes itself from the nearest siblings by saying get_mcp_hub/get_it are for MCP catalogs and that this tool DOES NOT list MCP 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 statement, names the preferred alternative for MCP machine catalogs, clarifies that those are publicLinks rather than this page, and ends with a NEXT routing instruction to get_mcp_hub or the /links HTML page. When-to-use, when-not-to-use, and alternatives are all 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?

The description discloses the output format, the edge case for geo_api ('empty for Hub/Legal/non-ort'), and behavioral parity with get_sitemap_txt. Since the annotations already declare readOnlyHint=true, the description adds meaningful context beyond that.

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 well-structured with a 'WHAT:' prefix and front-loaded details. Every sentence adds value—purpose, format, exclusions, and a behavioral note—without any filler.

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

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

Given the output schema covers return values, the description doesn't need to restate them. It covers the mapping, the format, exclusions, and the geo_api edge case, making it fully sufficient for an agent to call 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 parameters are well-documented in the schema itself. The description adds a reference to the same engine as get_sitemap_txt, but this doesn't materially change parameter meaning. Baseline 3 is appropriate.

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

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

The description uses a specific verb 'Fetch' with the resource '/llms-jsonld.txt' and explains the mapping purpose (URLs to relatedLink, mirrorId, geo_api). It explicitly distinguishes from siblings: 'Not the page body (use get_ai_page). Not get_serp_snippet.' This makes the tool's role 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?

It references the same engine as get_sitemap_txt for pagination behavior and explicitly states exclusions ('Not the page body', 'Not get_serp_snippet'). While it doesn't phrase an explicit 'use when...' directive, the context and exclusions clearly imply the appropriate use case.

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, and the description adds genuinely new behavioral context: the endpoint requires no login and returns a prose catalog of 47 Read/Link tools with call instructions. It does not cover pagination or error behavior, but with an output schema present, return-value disclosure is not required, so this is solid rather than maximal.

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 the WHAT, then USE, then sibling preferences and exclusions, in five tight fragments with zero filler. Every clause carries routing or scoping 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?

For a read-only fetch tool with a full output schema, 100% parameter coverage, and only a readOnlyHint annotation, the description supplies everything an agent needs: what is fetched, what it contains, auth status, and how it differs from the three nearest siblings.

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

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

Schema description coverage is 100% and both limit and offset are thoroughly documented in the schema itself (clamping, 0-based indexing, nextOffset paging). The description adds nothing about these parameters, so the baseline 3 for schema-documented params is correct.

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 (Fetch) and resource (/llms-mcp-server.txt) plus its exact nature ('prose catalog of THIS HTTP server, 47 Read/Link tools'). It explicitly distinguishes itself from siblings get_llms_mcp_web, get_llms_txt, and get_discovery, so an agent can route 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 use conditions ('USE for machine/server catalog text') and named alternatives with the conditions that select them ('Prefer get_llms_mcp_web for browser WebMCP catalog; prefer get_llms_txt for the general site index'). It also supplies negative exclusions ('Not the npm CLI README. Not maps.') and notes equivalence with get_discovery(which=llms-mcp-server), 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 already declare readOnlyHint=true, and the description adds real context beyond that: the file serves the same executeMcpTool handlers as HTTP /mcp over a different transport (document.modelContext), and it's a bootstrap catalog. It stops short of describing rate limits or content shape, but with an output schema present that is a minor gap.

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

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

Front-loaded with WHAT/USE/Prefer labels and zero filler sentences; every clause carries routing or scoping information. The telegraphic style and parenthetical asides are dense but still readable, costing it a point on structure rather than size.

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 fetch tool with full parameter documentation, an output schema, and safety annotations, the description covers purpose, transport semantics, sibling routing, and an explicit exclusion. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% and the schema itself explains line-based offset/limit, clamping, and nextOffset paging in detail. The description only says 'Optional offset/limit — see schema', which defers rather than adds meaning, so the baseline 3 applies.

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

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

States a specific verb (Fetch) and resource (/llms-mcp-web.txt) with its scope: 'browser WebMCP catalog (early bootstrap tools + full list)'. It explicitly distinguishes itself from get_llms_mcp_server and get_llms_txt, so an agent can route 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 'USE for WebMCP/UI discovery copy' plus two named alternatives with the condition that selects each ('Prefer get_llms_mcp_server for the machine/server catalog text; prefer get_llms_txt for the general site llms index'). It even adds an exclusion ('Not this streamable-http endpoint itself').

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 adds real behavioral context: it is an alias for get_discovery(which=llms-serp), it returns a line window, and omitting limit returns the whole file (a warning against doing so casually). It stops short of describing output shape or pagination limits, though 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?

Three dense, front-loaded sentences with WHAT/USE/Prefer structure; the key routing information appears early. Telegraphic phrasing ('USE for bulk SERP meta') is efficient rather than padded, though slightly clipped.

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, and the description covers identity, aliasing, windowing and alternatives. What an agent needs to choose and call this tool is essentially present; only return/pagination mechanics rely on 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% and both parameters already document offset/limit, clamping, defaults and nextOffset in detail. The description only reinforces the 'omit limit only if you need the whole file' rule, adding little 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 concrete verb and resource (/llms-serp.txt), names the exact content it returns (SERP title/description/URL corpus), and discloses that it is an alias of get_discovery(which=llms-serp). This clearly separates it from the dozens of get_llms_* siblings.

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

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

Explicitly says when to use it ('USE for bulk SERP meta') and routes the agent to two named alternatives with their selecting conditions: get_serp_snippet for a single URL's SERP block, get_llms_txt for the general site index. 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds behavioral context beyond the annotation: 'summary = file window' explains the tool's windowed return behavior, and 'Meta also as trailing # MCP-META lines in summary' discloses the meta-line format. This is valuable, though it does not mention auth or rate limits (likely unnecessary for a read tool).

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

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

The description is short, uses clear 'WHAT:' and 'USE' labels, and every sentence adds distinct value: fetch target, engine equivalence, summary semantics, recommended usage, full-dump alternative, and MCP catalog pointer. No filler or redundancy.

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

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

With an output schema, full parameter documentation, and readOnlyHint annotation, the description supplies the remaining needed context: why to use it, how it relates to alternatives, and what the summary contains. An agent has everything necessary to call the tool correctly and decide between 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?

The input schema provides 100% coverage with detailed descriptions for both limit and offset, including clamping, default values, paging via nextOffset, and line-based indexing. The description adds little beyond the schema, only referencing 'summary = file window' which is already implied by the schema's paging explanation. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Fetch https://www.ikeytz.com/llms.txt'. It also distinguishes itself from siblings by referencing get_discovery(which=llms) as the 'same engine' and get_llms_mcp_server as the MCP catalog alternative. An agent can clearly tell what this tool does and how it differs from similar 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 usage guidance is provided: 'USE as the first discovery read.' It names alternatives for fuller data ('Full dump: get_discovery(which=llms-full)') and for MCP catalog ('MCP catalog: get_llms_mcp_server'), giving the agent clear conditions for choosing this tool over others.

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 set readOnlyHint=true, and the description does not contradict that. It adds valuable context by clarifying that this is an HTML hub endpoint rather than the protocol endpoint, and describes the returned data structure (publicLinks, itPage, emails). This goes beyond the annotation's simple read-only flag, though it does not discuss side effects or permissions.

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

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

The description is compact and well-structured with clear demarcations (WHAT, NOT, RETURNS, USE). It packs extensive disambiguation into a few lines without redundancy, and the critical purpose is front-loaded. Every sentence contributes to correcting potential misuse or clarifying scope.

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

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

Given the tool's complexity—distinguishing from protocol endpoints, locale variations, and output structure—the description is thorough. It covers what it does, what it is not, what it returns, and how to use it. The existence of an output schema reduces the need to detail return values, yet the description still mentions key fields, making it complete for an agent to invoke correctly.

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

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

The schema fully documents the single 'locale' parameter (100% coverage), including its enum, default, and detailed behavior. The description itself does not mention parameters, so it adds no additional semantic value. Baseline 3 is appropriate because the schema already handles 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 immediately states 'WHAT: HTML hub /mcp-hub' and clarifies that it is not the protocol endpoint, explicitly distinguishing it from the POST endpoint. It also mentions it returns the same machines as get_it plus additional fields, giving a clear, specific purpose that differentiates it from sibling tools.

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

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

It says 'USE to cite discovery URLs,' which is a concrete usage scenario. It also provides exclusions like 'Not Italian, NOT the protocol endpoint' and warns about the Smithery listings and GitHub, helping the agent avoid misapplication. However, it does not explicitly state when to prefer this tool over get_it or mention alternatives, so it lacks a complete when-not-to-use section.

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 readOnly, but the description discloses the exact day/night rule, holiday dependence, Baden-Württemberg holiday nuance, Berlin timezone, and the returned fields. This makes the tool's behavior predictable beyond what readOnlyHint conveys.

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

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

The description is dense but cleanly structured with WHAT/THIS/RULE/RETURNS/USE/NEXT prefixes, and each fragment carries decision-relevant information. The core purpose is front-loaded, and the rule is stated precisely before workflow guidance.

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 clock/time tool with two optional params and an output schema, the description fully covers the operational rule, timezone, holiday edge case, disambiguation from a sibling, and downstream pricing/invoicing usage. An agent has everything needed to call and apply the result 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 coverrage is 100%, so the two optional parameters are already fully documented. The description adds contextual framing (clock, prices, before invoicing) but no new syntax or parameter-level detail, so baseline 3 is appropriate.

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

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

The description opens with WHAT, stating it is a Europe/Berlin wall clock to the second plus a day/night price key, and explicitly disambiguishes it from a maps.ikeytz.com geo-clock and from place lookup. An agent can identify the tool's exact role without opening the schema.

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

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

It gives an explicit USE-before-invoicing instruction and a NEXT step calling get_invoice_line_items, and it says the maps tool is a different clock. It also states what the tool does NOT do (no slug/plz lookup), which prevents misuse for geo queries.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral context: it is a stub pointer, does not return page body content, and returns a path with locale prefix stripped. This goes beyond the annotation and describes the exact behavior without contradiction.

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

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

The description is extremely concise with three short sentences, each carrying essential information. The key warning about being a stub pointer is front-loaded, and no wasted words exist.

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 stub-pointer tool with an output schema present, the description covers the core purpose, what it does not do, and alternative tools for real content. It could potentially mention the exact format of the returned path, but the output schema likely handles that. The description is sufficiently complete for correct invocation.

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

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

Schema description coverage is 100% for both 'path' and 'locale', including details like default values and locale prefix behavior. The tool description adds nothing beyond the schema's parameter descriptions, so it meets the baseline but does not enhance 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 clearly defines the tool's purpose: it returns a stub pointer (a path) rather than page content. It explicitly states what it is not ('NOT the page body') and distinguishes it from siblings by naming get_ai_page and get_serp_snippet as alternatives for real text. This leaves no ambiguity about the tool's role.

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

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

It explicitly instructs when to use alternatives: 'USE get_ai_page or get_serp_snippet for real text.' This gives clear guidance on when not to use this tool and what to use instead, fulfilling the usage guidelines dimension fully.

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 cover readOnlyHint. The description adds critical behavioral context beyond that: formSubmit=false, it never submits the partner form, and the agent must never claim the form was sent. This guardrail prevents a false success claim an annotation alone would not.

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, front-loaded structure (WHAT / USE / RETURNS / DOES NOT / NEXT) with zero filler. Every clause carries actionable routing or safety 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; the description still names the key field (partnerEmail) for the mailto flow. For a read-only, single-optional-param tool, 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?

The single locale parameter has 100% schema description coverage with enum values, prefix rules, and explicit non-effects. The description adds nothing about parameters, so the baseline 3 applies – the schema carries the full 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 ('Partner-werden page facts') and immediately distinguishes it from the sibling get_contact ('not general contact — that is get_contact'). An agent can select it 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?

Explicit when-to-use trigger (user asks about becoming a partner / Partner-werden), an explicit exclusion with the alternative named (get_contact), and a NEXT step routing to compose_mailto or /partner-werden. 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?

The description goes far beyond the readOnlyHint annotation by disclosing exact composition rules, pitfalls like 'never add 49 again,' exclusions for night/weekend/holiday, and the return structure: composition, opening, packages, surcharges, note. It also states 'No VAT (§ 19),' which is useful behavioral context not present in the annotation.

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

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

The description is dense and every sentence adds a constraint, return detail, or routing hint. It is front-loaded with the core purpose and avoids fluff, though the all-caps style and high information density make it slightly harder to parse.

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

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

For a pricing-composition tool with an output schema and one optional locale parameter, the description is unusually complete. It covers the tool's purpose, return shape, associated pitfalls, contact paths, and relationship to the sibling that computes totals. No critical calling information 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 schema description coverage is 100% and fully documents the single optional 'locale' parameter, including default behavior and URL prefix effects. The description adds no parameter-specific detail, but the baseline of 3 applies because the schema already carries the 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?

The description opens with 'Official Festpreis matrix + composition SYSTEM' and immediately states the tool's purpose: 'USE to understand how to assemble a price.' It also distinguishes itself from a sibling by saying 'DOES NOT compute one customer total — that is get_invoice_line_items(situationKey, whenKey).' This gives a specific verb, resource, and differentiation from other tools.

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

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

The description explicitly says when to use the tool ('USE to understand how to assemble a price') and when not to ('DOES NOT compute one customer total'), naming the exact alternative: get_invoice_line_items. It also gives routing hints to related tools like compose_whatsapp/compose_mailto and get_ort_datetime.

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, but the description adds real context beyond that: it discloses the failure mode for unknown slugs and the crucial boundary 'DOES NOT return the article body here', plus the follow-up call. This is meaningful behavioral disclosure, though it omits anything about output shape (already covered by the output schema).

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

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

Telegraphic WHAT/USE/NEXT structure with the scoping constraint and the non-return (body) front-loaded. Every clause carries routing or behavioral information; 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 pointer-fetch tool with an output schema and a readOnlyHint, the description covers the remaining agent questions: required input source, the alternative tool, the unknown-slug fallback, and the next call to retrieve fulltext. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds the provenance rule 'REQUIRED slug from list_ratgeber', telling the agent where a valid value comes from. The locale parameter's semantics are fully handled in the schema itself, so no extra credit is needed 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 and resource: 'Returns one Ratgeber page pointer (canonicalUrl /ratgeber/{slug})'. It immediately distinguishes itself from list_ratgeber by declaring it operates on a known slug, so an agent can route 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?

Explicit when-to-use ('USE when the slug is already known'), explicit alternative ('Prefer list_ratgeber when the slug is unknown'), and even an error-path rule ('Unknown slug → unknown_ratgeber (+ hub URL)'). This is exactly the routing guidance an agent 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?

The annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds that this is a redirect and enumerates the return fields (googleReviewUrl and canonicalUrl), plus the exclusion of rating lists. This is adequate behavioral context for a simple read-only URL getter.

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?

Every clause earns its place: WHAT, RETURNS, USE, and the not-a-list exclusion. The label-prefixed structure front-loads the key behavior and avoids filler. It is short but information-dense.

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 one optional parameter, a fully documented schema, an output schema, and readOnlyHint, all information needed to invoke the tool correctly is present. The description also prevents the natural confusion with aggregate review data. Nothing important 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 input schema documents locale with an enum, default, and a detailed explanation of path-prefix behavior, so 100% of parameter semantics are already in the schema. The tool description itself adds no parameter-level detail, but the schema makes that unnecessary. Baseline 3 applies.

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

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

The description opens with 'WHAT: Short /review redirect to the Google review URL,' naming the exact resource and behavior. It closes with 'Not a list of existing ratings,' which disambiguates it from rating/snippet tools. This is a specific verb-and-resource description that clearly separates 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?

'USE when the user wants to leave a review' is an explicit condition for invoking the tool. The negative clause 'Not a list of existing ratings' tells the agent when it is not appropriate. This is clear when/when-not guidance even though no sibling alternative is named.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral detail: it searches the first occurrence, returns matchContext with approximate character counts, returns serp_not_found on no match, and describes path-to-www conversion. This goes well beyond the annotation and is not contradicted.

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

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

The description is compact, front-loaded with WHAT, and uses clear labels such as RETURNS and 'Not a Google API.' Every clause earns its place, with no filler or repetition.

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

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

Given the read-only annotation, full schema coverage, and presence of an output schema, the description covers the essential invocation details: required parameter combination, locale behavior, failure return, and output format. An agent has enough context 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%, so the baseline is 3. The description adds extra meaning by stating that path or url is required in practice, explaining how non-http(s) paths are turned into www(locale, path), and clarifying that url can serve as the search needle. This is useful beyond the schema.

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

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

The description states a specific verb and resource: it returns a slice of /llms-serp.txt around the first occurrence of a target URL, including title/description/URL rows. It also explicitly disambiguates from a Google API, making the tool's scope clear.

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

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

The description gives practical guidance like 'path or url required in practice' and a negative exclusion ('Not a Google API'), so usage is partly implied. However, it never names alternative sibling tools or explains when to prefer this over related tools like get_llms_txt or get_sitemap_txt.

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

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

Beyond the readOnlyHint annotation, the description discloses the exact lookup precedence (slug before plz before substring), case-insensitive matching, the absence of a silent fallback, and the exact unknown-place error shape including ok=false, error=unknown_place, and hint=/einsatzgebiet.

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 dense but well-labeled with WHAT, RETURNS, USE, NOT, and NEXT sections. Every segment carries operational meaning, though some implementation jargon like 'getOrt' and 'ORTE' makes it slightly less crisp than it could be.

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

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

Given the rich input schema, readOnlyHint annotation, and presence of an output schema, the description covers everything needed to invoke correctly: lookup rules, error behavior, return fields, use-case trigger, and a suggested next step. No critical operational gap remains.

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

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

The schema already covers all four parameters at 100% coverage, so the baseline is 3. The description adds value above the schema by explaining how the parameters interact in the lookup order and by warning about the concrete 'plz 71638 → pattonville' first-match behavior.

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 starts with 'WHAT: One service-area place', which states a specific verb, resource, and singular scope. It distinguishes itself from sibling list_service_areas by emphasizing it returns one place, and it explicitly warns against nonexistent verify_zip_code/verify_coordinates tools.

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

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

'USE when the user names a town or PLZ' gives a clear trigger condition. The 'NOT verify_zip_code / verify_coordinates' warning and 'maps MCP is a second machine' note help prevent misrouting, though the description does not explicitly contrast with list_service_areas or other related siblings.

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

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

Beyond the readOnlyHint annotation, the description discloses the total URL count, the date of the dataset, the content breakdown, the intentional absence of maps URLs, and the summary structure including MCP-META fields (totalUrls, nextOffset, truncated). This gives an agent a concrete model of what the tool returns and how pagination behaves.

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 dense but organized: the WHAT line front-loads the core purpose, followed by size, composition, exclusions, and pagination. Every sentence contributes distinct information, and the terseness like 'marketing ×7 + discovery/media' is efficient rather than vague.

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

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

Given the readOnlyHint annotation, the detailed input schema, and the presence of an output schema, the description covers all the essential behavioral context an agent needs: what file is fetched, what it contains, what it intentionally omits, and how to page through results. 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 coverage for parameters is 100%, so the baseline is 3. The description adds value by contextualizing the parameters: it explains the sitemap size, that omitting limit returns everything, and that the pagination pattern applies specifically to sitemap.txt. It reinforces the schema without contradicting it, though much of the parameter detail is already in the schema.

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

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

The description names a specific verb and resource ('Fetch /sitemap.txt') and distinguishes it from related maps content by stating that maps.ikeytz.com entries are intentionally absent. It clearly defines the tool's scope and content set, making it easy to differentiate from sibling site-content tools.

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

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

The description gives explicit pagination guidance: use offset/limit + nextOffset to page, omit limit for the full list. It also excludes maps.ikeytz.com as a separate resource and, in the parameter description, advises using a window for llms-keywords.txt instead of the full list. This is actionable when-to-use and when-not-to-use guidance.

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

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

Discloses behavioral specifics beyond the readOnlyHint annotation: summary truncation to 500 chars, structuredContent excluding full body, and the wissen_not_found error. These shape agent expectations about response content and failure modes, which is exactly the kind of additive transparency needed.

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?

Compact label-based structure (WHAT, REQUIRED, summary, structuredContent, NEXT) makes it scannable and front-loaded. Each section earns its place; slightly dense, but efficient for an agent parsing it at runtime.

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?

Complete for a read-only single-item fetch: output schema covers return structure, annotations cover safety, and description covers truncation, error, and next steps. Minor omission is explaining whether locale affects content language or only URLs, but overall adequate.

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

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

Adds value by stating id must be an exact list_wissen item id, and clarifies locale prefix/default behavior. Schema coverage is 100%, so the description reinforces rather than compensates, but the error-case and content-shape details are useful semantic additions.

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 the exact resource ('One Wissen article'), the required parameter (id), and the key behavioral aspects upfront. The WHAT/NEXT structure makes it clear this is a single-item retrieval tool, distinguishing it from list_wissen and other get_* siblings.

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

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

Explicitly says id is required and must come from list_wissen.items[].id, and documents the unknown-id error case. It doesn't explicitly contrast with list_wissen or other content getters, but the NEXT fallback (get_ai_page) gives some routing guidance. Slightly more explicit alternative guidance would push this higher.

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

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

With readOnlyHint=true already covering the safety profile, the description adds valuable context beyond the annotation: the return shape (groups[] with id/hash/hubUrl/slugs/urls) and the cross-tool behavioral contract where an unknown slug produces ok=false unknown_auswahl in get_auswahl_item. It does not describe pagination or ordering, but those are minor for a hub listing.

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 format is front-loaded and zero-waste: the core purpose comes first, followed by the return contract and the usage routing. Every clause earns its place, and the structure makes scanning trivial for an agent.

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

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

For a low-complexity tool (one optional param, readOnly annotation, output schema present), the description is complete: it states what it does, what it returns, when to use it, and the downstream failure mode. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, and the locale parameter's schema description is exceptionally detailed (defaults, URL prefix behavior, what it does not change, maps-locale exclusion). The tool description adds nothing about locale, so the baseline 3 applies — the schema does the heavy lifting, which is acceptable.

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

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

The description states a specific verb (list) and resource ('Auswahl hub groups'), anchors it to a concrete endpoint (/auswahl), and differentiates it from the sibling get_auswahl_item by framing this as the slug-discovery counterpart. An agent can tell exactly what this tool does 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?

The description gives an explicit use case ('USE to discover valid slugs for get_auswahl_item') and names the sibling it feeds into, plus the downstream failure contract for unknown slugs. It lacks explicit when-not-to-use exclusions versus other listing/search siblings, but the primary routing logic is unambiguous.

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