ikeytz - Schlüsseldienst Ludwigsburg

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

Annotations only declare readOnlyHint=true; the description adds real behavioral context beyond that — it does not send email, the empty-argument call still produces text (beratung) rather than a bare mailbox, and the partner email lives elsewhere. These are meaningful side-effect/default disclosures, though no rate limits or return shape are discussed.

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:' clause leads with the generated target and the reused prefab, then the negative constraints. Telegraphic phrasing ('option = contactOption of one of the 10 end-invoices') is dense but earns its space; no filler sentences.

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

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

For a one-parameter, read-only composer with a 100%-covered schema and an output schema (so return format needn't be explained), the description covers default behavior, absence of sending, and the correct alternative source for the partner mailbox. Nothing essential to a correct call 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 enum itself documents every value, so the schema carries the parameter burden. The description restates the default ('Omit = beratung') and roughly groups the allowed values, which duplicates rather than extends the schema; the grouping is also loose since it names 12 of the 15 enum members without accounting for zugefallen/abgeschlossen/zylinder.

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 (builds a mailto: to info@ikeytz.com using the compose_whatsapp prefab with subject+body) and explicitly contrasts itself with siblings compose_whatsapp and the tel-compose tools, plus clarifies what it is NOT (not the partner mailbox seen on get_partner_info). An agent can distinguish it from every sibling without opening a schema.

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

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

Gives concrete invocation guidance: the option must be one of the listed prefab ids, and calling with {} yields the beratung advice template rather than an empty mailbox. It also rules out use for the partner mailbox. It never states explicitly when to choose this over compose_whatsapp/compose_tel_mobile, so a 5 is not warranted.

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 only that the call takes no arguments and repeats sibling routing; it adds little else about determinism or that the result is a fixed public href (which sits in the schema description). Adequate but thin beyond the 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?

Two short clauses, front-loaded with WHAT and the routing hint; every word earns its place with no padding.

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

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

For a zero-argument, read-only tool with an output schema, the description plus schema fully cover what an agent needs to invoke it correctly. The only marginal gap is not restating the exact returned value, which the output schema already handles.

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

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

The tool takes zero parameters, which is the baseline-4 case. 'Call with {}' reinforces the empty-argument contract and matches the schema and annotations with no conflict.

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

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

States a specific resource and output ('tel: href for the landline (Festnetz)') and explicitly differentiates itself from the nearest sibling by name ('Mobile/24h emergency = compose_tel_mobile'). An agent can tell it apart from compose_tel_mobile without opening either schema.

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

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

Names the alternative sibling and the condition that selects it (mobile/24h emergency), which is exactly the routing decision an agent needs. It does not spell out the positive 'use when' case for the landline explicitly, but for a zero-arg compose tool the alternative routing is the useful part.

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 real context beyond that: it confirms the tool is argument-free, discloses the exact return shape (href and canonicalUrl as tel:+49…), and warns the agent not to fabricate a completed call.

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 layout is front-loaded and every clause carries information. 'Call with {}' is mildly redundant given the empty schema, but it is not wasteful enough to penalize heavily.

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 enumerate return values, and it is complete for a static, side-effect-free href composer: no args, known return, sibling routing, and a user-facing instruction. Only the mobile-vs-landline selection criterion is left implicit.

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

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

The tool takes zero parameters, so the baseline is 4. The description's 'Call with {}' and the schema's 100% coverage both confirm no arguments are expected, adding nothing contradictory.

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

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

States a specific resource (a tel: href for the 24/7 mobile number) and clearly distinguishes itself from the sibling compose_tel_landline by name. An agent can select it 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?

It names the alternative (compose_tel_landline) and gives an actionable directive ('Show this to the user; do not pretend the call happened'). However, it never states the condition under which mobile should be chosen over landline, leaving that to inference.

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

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

With readOnlyHint=true already covering the safety profile, the description adds the key operational fact that it 'Does not send WhatsApp' — distinguishing URL generation from an actual message dispatch. It also discloses that deprecated aliases 'set ambiguous=true', a side effect not visible in the annotations or 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?

Front-loaded with WHAT, then constraints, then the alternative — no filler sentences and every clause carries operational content. The jargon-dense opening ('one prefab = one end-invoice (or mount 49 / beratung)') is hard to parse on first read but not wasteful.

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

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

An output schema exists, so the return value need not be explained, and the description covers option semantics, defaults, and deprecated-alias behavior. It leaves minor gaps (exact URL formatting, what ambiguous=true does downstream) but is complete enough to call the tool correctly.

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

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

Schema coverage is 100% and the enum already carries descriptions, so the baseline is 3, but the description meaningfully extends it: alias→*day invoice mapping, the ambiguous=true consequence, the beratung default, and the '49 € is mount, not night' pricing distinction.

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?

Opens with 'WHAT: Build a https://wa.me/… URL', a specific verb+resource that an agent can act on immediately, and the sibling names (compose_mailto, compose_tel_*) make the channel obvious. It does not explicitly contrast itself against those siblings, but the WhatsApp/wa.me framing is unambiguous.

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

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

Gives real routing rules: 'Omit/unknown → beratung' for the default, 'do not use them' for deprecated aliases, and 'List via list_whatsapp_options' to point at the discovery sibling. It stops short of stating when this tool should be chosen over compose_mailto/compose_tel, so it isn't a full when/when-not guide.

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

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

Annotations only declare readOnlyHint; the description adds substantial non-obvious behavior: matching is case-insensitive, the file is a phrase-to-URL map, the empty-q failure mode returns q_required, and locale does not filter the file. Those details would otherwise have to be discovered by trial and error.

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

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

Front-loaded with WHAT/USE/NEXT labels and zero filler; every clause carries information. The telegraphic, abbreviation-heavy style is efficient but slightly harder to parse than plain 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?

An output schema exists, yet the description still sketches the return shape (q, count, lines[] as raw TSV-like rows), and it covers the error path, hard limits, and the next tool to call. Nothing an agent needs to invoke 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 description coverage is 100%, so the baseline is 3. The description restates q as REQUIRED and the 15/30 limit bounds (redundant with schema) but adds the genuinely new fact that locale does not filter the keyword file, which the schema does not convey.

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: case-insensitive substring search over the named llms-keywords.txt phrase-to-URL map. That scope cleanly separates it from siblings like resolve_locale_url, get_ai_page, and the list_* tools, which do not do substring lookup.

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

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

"USE to map a user phrase to URLs" gives explicit positive guidance, and "NEXT: get_ai_page on a returned www path" supplies the follow-up call. It stops short of naming when NOT to use it (e.g. versus resolve_locale_url for known paths), so it falls just below the top tier.

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 read safety (readOnlyHint=true), so the description adds real value by disclosing that this is a pointer/locator rather than a content-bearing tool — the NEXT step to get_ai_page implies the actual page content comes from elsewhere. It doesn't describe the return shape, but an output schema exists to cover 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 WHAT/NEXT structure is heavily front-loaded and wastes no words, fitting a compact pointer tool. The telegraphic phrasing is efficient, though slightly cryptic without the surrounding context.

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 needn't be explained, and the description supplies the destination path plus the follow-up call. For a single-parameter read-only pointer tool this is nearly complete, missing only a note on what the pointer itself contains.

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 already fully documented with enum semantics and prefix behavior in the schema. The description contributes no additional locale guidance, so the baseline 3 applies.

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

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

The description names the resource it points to ('/ueber-uns (about, owner)') and explicitly distinguishes itself from get_business_identity for NAP facts, so an agent can route between the two. It is terse but specific enough to identify what this tool returns (a pointer, not the page content).

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

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

It names the alternative for a specific case ('For NAP facts prefer get_business_identity') and prescribes the follow-up call ('NEXT: get_ai_page(...)'), effectively telling the agent when to use this and what to do next. There is no explicit when-not for the tool itself, but the routing is 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 only cover readOnlyHint=true, so the description carries real behavioral weight: it discloses the URL construction pattern, the path=→index.txt resolution rule, the 4000-char summary truncation with a truncated flag, and the /review no-footer edge case. It stops short of describing error behavior or rate limits, but adds strong context beyond the single 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?

WHAT/USE/NEXT labeling front-loads purpose, then routing, then follow-ups, with zero filler sentences. Telegraphic shorthand is dense but every clause 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?

An output schema exists, so return-value documentation is not needed; the description still covers purpose, sibling routing, path resolution, and truncation. For a 2-param read tool this is fully 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?

Schema coverage is already 100%, so baseline is 3, but the description adds the file-mapping semantics (path=/ → index.txt; else path stripped of leading slash + .txt) that the schema does not state. This gives an agent the derived request target rather than only the parameter format.

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 (fetches) and resource (HTML-parity fulltext for one marketing URL), and proactively names the siblings it is not (get_ai_txt, get_serp_snippet). An agent can distinguish it from the other 'get_ai_*' and 'get_serp_*' tools without opening a schema.

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

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

Explicit 'USE for page body text — not site-wide crawl/train policy (that is get_ai_txt)' and 'Not get_serp_snippet (title/description only)' give when-to-use, when-not, and the exact alternative for each case. 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 only declare readOnlyHint, so the description must supply the rest. It discloses a negative boundary ('DOES NOT return page bodies') and paging behavior (offset/limit windows, nextOffset carry-forward) beyond the safety hint. It stops short of stating rate limits, auth requirements, or what the policy text authorizes downstream (e.g., quoting obligations), so it is strong rather than complete.

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-loads WHAT and USE in a compact, telegraphic style with zero filler sentences. The parenthetical enumeration of policy fields is borderline extraneous but still informative, keeping it just shy of a 5.

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

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

With an output schema present and read-only annotations covering safety, the remaining agent needs are scope, alternatives, negative boundaries, and paging — all present. Nothing required 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 description coverage is 100%, so the parameters are already fully documented including defaults, ranges, and nextOffset paging. The description only gestures at them ('Optional offset/limit page large files — see parameters / nextOffset in schema'), adding no format or edge-case detail 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?

Opens with a specific verb and resource ('Fetch /.well-known/ai.txt') plus a scope summary ('site-wide crawl/training policy'), which immediately distinguishes it from per-URL siblings. It also names what the file contains (ai-input/ai-train/contact), so an agent knows the payload semantics without opening anything.

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

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

Gives an explicit use condition ('USE for policy before quoting') and routes away from two named siblings with the condition that selects each: get_ai_page for per-URL fulltext, get_discovery only when a generic file window is needed. This is exactly the when/when-not/alternative structure the dimension asks for.

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 the URL shape (/auswahl/{slug}) and return fields, which is useful context beyond the annotations, though the output schema already carries some of 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?

Terse telegraphic WHAT/REQUIRED/RETURNS/USE/NEXT structure front-loads the essential facts, and every clause carries information with no filler.

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

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

For a two-parameter read tool with an output schema and readOnly annotation, the description covers retrieval, slug source, return shape, and follow-up routing. 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 coverage is 100%, so the baseline is 3, but the description adds genuine meaning by stating the slug must come from list_auswahl's situation slugs (not Ort slugs), clarifying provenance and disambiguation not present 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?

States a specific verb+resource ('One Auswahl situation page') and identifies the sibling it depends on and is distinct from ('REQUIRED slug from list_auswahl'), so an agent can separate it from list_auswahl immediately.

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

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

'USE after the user described a lockout/key situation' gives an explicit trigger, and 'NEXT: get_ai_page(...) for fulltext; get_invoice_line_items for euro' routes the agent to the right follow-up tools. When-to-use and alternatives are both covered.

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

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

Annotations only declare readOnlyHint=true; the description goes well beyond that by stating it does not accept updates, that it cannot prove licenses beyond what the site states, and that walkIn is always false with an explicit instruction not to send customers to the office — a behavioral constraint no structured field 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?

Labeled sections (WHO/RETURNS/USE/DOES NOT/NEXT) front-load the routing information and every clause is keyword-dense rather than padded. The RETURNS enumeration partially duplicates the existing output schema, which is the only mild 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 zero-required-parameter read tool with a full output schema and one enum param, the description covers purpose, exclusions, behavioral constraints, and next steps. 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 description coverage is 100% and the single locale parameter is fully documented in the schema (enum, default, prefix semantics), so the description adds no locale-specific detail beyond noting canonicalUrl = /impressum. Baseline 3 applies when the schema carries the 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?

Opens with an explicit verb+resource+scope ('Legal/trade identity and NAP for agents and citations') and enumerates the concrete fields returned. Any agent can distinguish it from get_contact, get_legal, or get_about without inspecting a schema.

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

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

The USE clause names concrete triggers (impressum-grade facts, schema.org LocalBusiness fields, 'who owns ikeytz'), the DOES NOT clause excludes a plausible misuse (proving licenses beyond site statements), and the NEXT clause routes to the correct siblings (get_legal(doc=impressum), get_contact, get_geo_office).

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, but the description adds a real behavioral safeguard beyond them: it does not submit the website contact form and the agent must not claim it did. It also implies an object return. It stops short of disclosing response structure or whether fields can be null/absent, so not a full 5.

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

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

The WHAT / DOES NOT / USE / NEXT labeling front-loads the essential information and each clause earns its place with zero filler. Well-sized for a single-parameter read tool.

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 return shape need not be explained, and the enumeration of fields plus the form-submission caveat cover the agent's needs. Nothing required 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 description coverage is 100% and the single 'locale' parameter is thoroughly documented in the schema itself (enum values, URL prefix behavior, default). The description does not touch locale at all, so the baseline 3 is the correct score.

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

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

The WHAT clause names the exact resource returned (public phones, fax, email, office address object), and the DOES NOT and NEXT clauses clearly distinguish this read-only contact tool from the compose_* siblings. An agent can tell what it gets and what it is not.

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 to give the user a number' plus a concrete NEXT list (compose_tel_mobile, compose_tel_landline, compose_mailto, compose_whatsapp, list_whatsapp_options) routes the agent to the right follow-up tools. It also gives an explicit exclusion (does not submit the contact form).

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 goes well beyond that: it discloses the ~30KB truncation window (O9), that an explicit limit changes truncation behavior, that nextOffset enables paging, that a trailing # MCP-META block carries truncated/totalUrls/nextOffset, and that policy files state ai-train=no. Truncation and error semantics are exactly the kind of behavior annotations cannot express.

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/REQUIRED before detail, and nearly every clause carries operational information. It is dense to the point of being telegraphic ('O9', '~30KB', packed ID list), which costs a little readability, but there is little pure filler.

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

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

With an output schema present, the description need not explain return values, yet it still summarizes the MCP-META trailer. Combined with alias handling, pagination mechanics, truncation rules, and the unknown_discovery error code, an agent has everything needed to call this correctly on the first try.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value: a concrete list of accepted `which` values, alias folding (underscores, get_ prefix, _txt suffix, locale slices like llms-keywords-en), and framing offset+limit as a sliding window keyed to the prior nextOffset. It largely restates the limit rule already in the schema, so it does not rise above 4.

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?

Opens with a specific verb+resource+scope: 'Fetch one public discovery file from www and return a line window.' It also distinguishes itself from the many dedicated siblings by naming the get_llms_* / get_sitemap_txt family, so an agent can tell this is the generic fallback rather than the specialized reader.

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

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

Gives an explicit routing rule: 'Prefer dedicated get_llms_* / get_sitemap_txt when you know the file,' which maps directly onto siblings in the tool list. It also documents the failure path (unknown which → unknown_discovery). No explicit statement of when this tool should *not* be used, but the context is 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 declare readOnlyHint=true, and the description adds real behavioral context beyond that: it returns a page pointer rather than performing an action, explicitly does NOT dispatch a technician or take a booking, and the summary includes the mobile number. It doesn't cover auth needs or rate limits, but for a safe read-and-route tool this is solid disclosure.

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

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

Front-loaded WHAT / USE / DOES NOT / NEXT labeling makes the dense content scannable, and every clause carries information an agent needs (trigger, alternatives, negative boundary, next step). No filler sentences.

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

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

An output schema exists, so the returned fields need not be re-explained; the description instead supplies the missing decision context (when to use, what it is not, what to do next). Nothing an agent needs to select and call this tool is absent.

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

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

Schema description coverage is 100% and the single locale enum is documented exhaustively in the schema (prefix rules, default, what it does not affect). The only addition in the description is the phrase 'locale-prefixed,' which is marginal over the schema, so baseline 3 applies.

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

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

States a specific verb (Returns) and resource (24h Notfall-Türöffnung page pointer), including the canonical URL path, and names both siblings it is not (get_contact for NAP, compose_tel_mobile to dial). An agent can distinguish it from its many get_* siblings without opening a schema.

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

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

Explicit USE clause names the triggering scenario (emergency door-opening contact on www) plus two preferred alternatives with their conditions. It also states the negative boundary (does not dispatch or book) and a follow-on route via list_whatsapp_options/compose_whatsapp.

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

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

Annotations only supply readOnlyHint=true; the description adds real behavioral context the annotations lack: id-first-then-substring resolution order, the faq_not_found outcome for misses, and a boundary against the calculator/invoice tools. It does not describe pagination or result shape, but for a single-lookup tool 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 a 'WHAT:' label, then lookup order, boundary, failure mode, and routing hint — every clause carries distinct information with no filler. The telegraphic style is dense but purposeful.

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

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

With a full output schema and readOnlyHint already covering the return shape and safety profile, the description supplies everything else an agent needs: resolution order, error outcome, and the alternative tool for numeric/calculation needs.

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 id/q/locale semantics are already fully documented in the schema (including 'Tried first if present' and 'Fallback search'). The description restates the cross-parameter precedence but adds no syntax or format detail beyond it, so the baseline 3 applies.

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

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

States a specific verb and resource ('One FAQ Q+A') and immediately distinguishes itself from siblings by scoping to a single entry versus the list_faq list. The parenthetical examples (Ausweis, MwSt, 24h) make the resource concrete.

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 lookup precedence ('exact id, else first substring on q'), an explicit exclusion ('Not a calculator — ... use get_invoice_line_items'), the failure path ('Missing → faq_not_found'), and a routing hint ('Prefer id from list_faq'). When-to-use, when-not, 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?

With readOnlyHint=true the safety profile is already covered, but the description adds meaningful non-schema behavior: walkIn=false, 'never send customers to walk in', and google_business being an 'external click only' share. It does not discuss rate limits or caching, but the added behavioral constraints are substantive.

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 and organized with WHAT / RETURNS / NOT / NEXT markers, and the routing constraints come early. However the RETURNS list enumerates many fields that the output schema already carries, which is mild redundancy against a 10% dimension.

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-param, read-only geography tool with a full output schema, the description plus annotations cover everything an agent needs to call it and to route away from it correctly. Nothing material 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 is only one optional parameter and schema description coverage is 100%, so the schema fully owns locale semantics (prefix behavior, defaults, what it does not change). The description adds no locale-specific detail itself, so the baseline 3 applies.

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

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

States a specific verb+resource (retrieves the registered office / Firmensitz geo record) and even gives the concrete value (Adalbert-Stifter-Str. 14). It explicitly distinguishes itself from related siblings, saying it is 'NOT a service-area place map (use list_service_areas / get_service_area for Ort slugs)'.

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-not conditions ('NOT a shop — never send customers to walk in', 'never send customers to walk in') and names the alternative sibling tools for service-area lookups. It also points to plausible next calls (get_contact, get_legal(doc=impressum), or the maps MCP).

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 carry readOnlyHint=true, but the description adds real behavioral context beyond that: no VAT, aliases, that breakdown=true splits a combo without changing totalEur, and guardrails ('Do not invent euro', 'Do not add 49 on top of pkg_key_*'). It stops short of stating nothing else about failure modes or limits, so a 4 rather than 5.

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

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

Front-loaded with WHAT/NOT/FIRST/THEN/NEXT/RETURNS markers so the sequence is easy to parse, and every clause carries domain rules. It is dense and jargon-heavy, which costs a point, but there is little pure 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 complex pricing tool with an output schema, the description covers classification inputs, required keys, aliases, edge cases (night vs 49, mount vs end-invoice) and the next tool to call. Nothing an agent needs to invoke it correctly appears missing.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds cross-parameter meaning by tying whenKey to get_ort_datetime, explaining the breakdown split behavior, and mapping aliases to situationKey values. It mostly enriches relationships rather than merely restating fields.

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 ('Computes ONE of the 10 end-invoices') and immediately scopes it against neighbors with 'NOT a booking, NOT a PDF'. An agent can distinguish it from compose_* and get_prices without opening the schema.

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

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

Gives an explicit decision procedure: FIRST classify via get_prices.composition.routes with enumerated rules, THEN derive whenKey from get_ort_datetime, NEXT call compose_whatsapp/compose_mailto. It names the upstream and downstream tools and the conditions selecting each route.

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

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

Annotations only declare readOnlyHint=true; the description adds real behavioral context beyond that — 'www /mcp never calls maps /mcp', proxy=false, and the disambiguation that '/it is not Italian'. That cross-endpoint isolation is genuinely useful and not in the structured fields.

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

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

It uses a WHAT/RETURNS/USE structure which is front-loaded, but the RETURNS block is a dense brace-notation dump of the response shape that duplicates the existing output schema, consuming space without adding value.

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 needn't be explained, and the description does cover the key concept (two endpoints, isolation, disambiguation). It is complete enough for an agent to call it correctly, despite the redundant RETURNS section.

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 locale enum is thoroughly documented in the schema itself, so the baseline of 3 applies. The description adds no parameter-level meaning beyond what the schema already provides.

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?

It states the resource ('HTML page /it — two MCP machines documented') and distinguishes itself from get_mcp_hub, but the purpose is buried in cryptic jargon and the opaque name 'get_it' isn't resolved to a clear verb+resource. An agent can infer it fetches a page, but the phrasing is hard to parse.

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

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

It gives an explicit trigger ('USE to tell an agent there are TWO endpoints (www vs maps)') and points to the sibling get_mcp_hub for the hub HTML. It lacks explicit when-not-to-use guidance, but the routing context is 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?

With only readOnlyHint in annotations, the description adds substantial behavioral context: the error contract (ok=false, unknown_doc, hint=/impressum), the return shape (doc + canonicalUrl), and the authority note that German legal text is binding while the EN copyright file is a courtesy.

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 / RETURNS labels and no filler; every clause (error case, alternatives, language authority) carries actionable information. Dense but each sentence earns its place.

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

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

An output schema exists, yet the description still summarizes the return and error contract, plus language authority. Combined with full schema coverage, nothing needed to call the 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 coverage is 100%, so the schema already documents both enums, defaults, and locale behavior, establishing a baseline of 3. The description adds a small amount beyond schema by showing how doc maps into a path ('/'+doc) and flagging doc as 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?

States a specific verb+resource ('Pointer to one legal HTML page') and immediately clarifies it is a pointer, not the full text. Names the sibling tools that deliver full content (get_ai_page, get_discovery), so an agent can distinguish it from them 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?

Explicitly routes the agent: use this for the pointer, call get_ai_page for full text, or get_discovery for the copyright corpus. It also states the error path (unknown doc → ok=false with hint=/impressum), giving clear when-and-what-happens 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 declare readOnlyHint=true, so the description adds real context: what the page actually contains, that it is an HTML page, and the publicLinks-vs-this-page distinction. It stops short of describing return shape, but an output schema exists so that burden is carried elsewhere.

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

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

The WHAT/USE/DOES NOT/NEXT structure front-loads purpose and routes the agent in four dense clauses with no filler. Every sentence 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?

With an output schema present, return values need no explanation, and the description covers purpose, contents, exclusions, alternatives, and the next step. 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% and the single enum parameter is thoroughly documented in the schema itself (default, prefix behavior, what it does not affect). The description adds no parameter-level 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 resource ('Pointer to /links') and enumerates its contents (local directories, city sites, HWK, Webmail shortcut), then explicitly negates what siblings cover ('DOES NOT list MCP tools'). An agent can distinguish it from get_mcp_hub/get_it without opening any schema.

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

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

Explicit USE condition ('human directory/backlink list'), an explicit alternative with its own condition ('Prefer get_mcp_hub (or get_it) for MCP machine catalogs'), and an explicit exclusion ('DOES NOT list MCP tools'). 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 cover readOnlyHint=true, and the description adds substantial context beyond that: the payout format, the shared engine with get_sitemap_txt (offset/limit/nextOffset/# MCP-META), and that geo columns are empty for Hub/Legal/non-ort. This is exactly the extra behavioral context annotations do not carry.

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 front-loaded with WHAT and the format, then exclusions. It is long, but nearly every clause encodes a distinct fact; the one weak spot is the 'Ort/PLZ' glossary shorthand which assumes site-specific vocabulary an agent may not have.

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 file-fetch tool with a full output schema, the description covers format, engine behavior, paging meta, and domain exceptions. The only gap is that the Ort/PLZ distinction is explained in terse German shorthand rather than plain terms, which could leave a non-domain-aware agent guessing.

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 both parameters have rich descriptions including the ~30KB window rule and offset/nextOffset paging. The description only restates the paging engine by reference, adding nothing beyond the schema, so the baseline 3 applies.

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

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

The description names a specific artifact (/llms-jsonld.txt), enumerates exactly what it maps (marketing HTML URL → relatedLink + mirrorId + optional geo columns), and gives the tab-separated column layout. It explicitly distinguishes from get_ai_page and get_serp_snippet, so an agent can tell it apart from siblings without opening a schema.

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

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

It states when-not to use it ('Not the page body (use get_ai_page). Not get_serp_snippet') and explains the Ort vs PLZ line semantics (one URL each vs pipe-separated per Ort). It does not say which sibling to use when the goal is the JSON-LD itself versus other llms_* variants, so a 5 is not warranted.

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

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

Annotations only declare readOnlyHint=true; the description adds genuinely new behavioral context — no login required, content is a static prose catalog, and the equivalence 'Same as get_discovery(which=llms-mcp-server)'. It stops short of describing pagination/window behavior, but the schema already covers 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?

Front-loaded WHAT/USE structure packs routing, alternatives, and exclusions into a few telegraphic sentences with minimal waste. The clipped fragments ('Not the npm CLI README. Not maps.') are efficient but slightly choppy, keeping it just below top marks.

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 catalog fetch with a full output schema and fully documented parameters, the description covers everything an agent needs: what the endpoint returns, when to pick it, and which siblings to prefer. Return-value and pagination details are correctly left to the structured fields.

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

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

Schema description coverage is 100% and both limit/offset are documented in detail there, so the schema does the heavy lifting. The description adds no parameter-level syntax or format guidance, making the baseline 3 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 and resource ('Fetch /llms-mcp-server.txt — prose catalog of THIS HTTP server') and adds scope detail (47 Read/Link tools, how to call, no login). It explicitly names the siblings it is not (get_llms_mcp_web, get_llms_txt) so an agent can route without opening the schema.

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

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

Gives explicit when-to-use ('USE for machine/server catalog text'), two named alternatives with the conditions that select them, and negative exclusions ('Not the npm CLI README. Not maps.'). Nothing about selection is left to inference.

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

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

Annotations only cover readOnlyHint, so the description usefully adds that it shares executeMcpTool handlers with HTTP /mcp under a different transport (document.modelContext) and points to offset/limit behavior in the schema. It stops short of describing pagination/chunking traits beyond the pointer, so it is not fully comprehensive, but it clearly exceeds what the single annotation 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?

Dense but front-loaded, with WHAT/USE markers that let the agent skip to the relevant clause. The closing 'Not this streamable-http endpoint itself' is a slightly confusing negative that costs a bit of clarity.

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

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

An output schema exists so return values need not be explained, readOnlyHint covers safety, and the description handles the routing ambiguity created by many llms_*/mcp_* siblings. 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% and both parameters carry detailed semantics (line-based windowing, ~30KB default, nextOffset paging). The description only adds a pointer ('Optional offset/limit — see schema') with no meaning beyond the schema, so baseline 3 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-web.txt — browser WebMCP catalog), and explicitly distinguishes itself from two named siblings, get_llms_mcp_server and get_llms_txt. An agent can route without opening the schema.

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

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

Explicit 'USE for WebMCP/UI discovery copy' plus two named alternatives with the condition that selects each. This is textbook when-to-use/when-not routing.

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

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

Annotations only declare readOnlyHint=true, so the description carries most of the burden and does add value: it reveals the alias relationship to get_discovery and warns that limit should be omitted only when the whole file is actually needed, implying a large-payload cost. It stops short of describing pagination mechanics or response shape in the description itself, but the output schema covers the return contract.

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 labelling makes it scannable, and every clause earns its place: identity, alias, parameter posture, and two disambiguating alternatives in three short sentences with zero filler.

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

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

With two optional, fully documented parameters and an output schema carrying the return contract, the description supplies everything an agent needs: what the file is, that it is paginated via offset/limit, and which sibling to choose instead when the scope is narrower.

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 limit/offset descriptions already spell out the 30KB window, nextOffset paging and line-vs-byte semantics, so the schema does the heavy lifting. The description's 'omit limit only if you need the whole file' adds light decision framing but no syntax or format detail beyond the schema — baseline 3.

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

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

States a specific verb+resource ('Returns /llms-serp.txt — the full SERP title/description/URL corpus as a line window') and goes further by disclosing the alias get_discovery(which=llms-serp), which lets an agent map it onto the discovery family. It explicitly contrasts itself with get_serp_snippet and get_llms_txt, so it is distinguishable from siblings 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 an explicit positive trigger ('USE for bulk SERP meta') and two explicit alternatives with their selecting conditions ('Prefer get_serp_snippet for one URL's SERP block; prefer get_llms_txt for the general site index'). This is the when/when-not/alternative pattern done properly.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds that this is a windowed read ('summary = file window') and that it shares an engine with get_discovery, but leaves pagination/truncation detail to the schema rather than restating behavioral traits.

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 WHAT/USE telegraphic format with zero filler and the primary action front-loaded. Slightly cryptic compression (e.g. 'short AI landmap') but every fragment carries routing or scope information.

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

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

With an output schema present, return-value explanation is unnecessary, and annotations cover the read-only profile. The description supplies purpose, entry-point positioning, and sibling routing; only minor file-content expectations are unstated, which is acceptable for a well-schematized fetcher.

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

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

Schema description coverage is 100%, so limit and offset (including the ~30KB window and nextOffset paging semantics) are fully documented in the schema. The description adds only 'summary = file window', which is marginal beyond the structured fields. 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.txt), gives the exact URL, and characterizes it as the 'short AI landmap'. It explicitly distinguishes itself from the sibling get_discovery(which=llms-full) and get_llms_mcp_server so an agent can differentiate 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?

Explicitly routes usage: 'USE as the first discovery read', then names the full-dump alternative (get_discovery which=llms-full) and the MCP catalog alternative (get_llms_mcp_server). Conditions for selecting each sibling are given, which is exactly the when/when-otherwise guidance required.

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

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

readOnlyHint=true already covers the safety profile, and the description adds real context beyond it: the exact return shape (publicLinks with website[] and maps[] contents), the fact that the protocol endpoint remains POST .../mcp, and the caveat that two Smithery listings map to two machines. This is genuine added behavioral context.

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

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

The WHAT/RETURNS/USE labels front-load the important parts, which is good structure, but the body is a dense run-on of abbreviations and parentheticals that is hard to parse on first read. Some of the enumerated link sources (SSL Labs, Glama, getlulu) are padding rather than decision-relevant.

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

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

An output schema exists, so return values needn't be spelled out, yet the description still documents them helpfully. Combined with the usage cues and exclusions, an agent has enough to call this correctly, though the dense phrasing leaves the get_it-vs-mcp-hub selection slightly under-specified.

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

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

Schema coverage is 100% and the locale enum is fully documented in the schema, including the de-has-no-prefix rule. The description merely echoes that ("de has no prefix") and adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The WHAT/RETURNS/USE structure states a specific resource (HTML hub /mcp-hub) and explicitly differentiates it from the protocol endpoint and from get_it by listing the extra publicLinks it returns. It names the sibling get_it it overlaps with, so an agent can separate them. The density of abbreviations (npm CLI, SSL Labs, Glama) muddies it slightly but the core purpose is clear.

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

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

It gives an explicit use case ("USE to cite discovery URLs") plus concrete exclusions ("NOT Italian, NOT the protocol endpoint... Not GitHub. Not com.ikeytz/website"). It lacks a when-not-to-use-this-instead-of-get_it condition, but the routing cues are strong.

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

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

Annotations only declare readOnlyHint=true; the description adds substantive behavior beyond that — the full whenKey classification rule (day = Mo–Fr 08:00:00–17:59:59 Berlin and not a Baden-Württemberg statutory holiday, else night) plus the holiday-detection logic. That is real business behavior an agent cannot infer from structured fields.

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/RULE/RETURNS/USE/NEXT labels, which makes the density navigable, and every rule sentence earns its place. It loses a point because the long RETURNS field list duplicates an output schema that already exists, which is redundant per the stated guideline.

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 timezone+holiday clock tool, the description covers the classification rule, the tool-routing, and the sibling distinction, while the output schema carries return shape. An agent has everything needed to call it and chain it into invoicing.

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 both parameters (at, locale) are already fully documented in the schema. The description adds essentially nothing about at/locale semantics, so the baseline 3 applies; its whenKey discussion concerns an output field, not inputs.

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

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

States a specific verb+resource+precision: 'Europe/Berlin wall clock to the second + whenKey for prices.' It also explicitly distinguishes itself from a similarly-named sibling ('THIS www tool does NOT look up a place (no slug/plz). maps.ikeytz.com has a different geo clock tool'), so an agent can route without opening either schema.

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

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

Gives an explicit when ('USE before invoicing'), a when-not ('does NOT look up a place'), and concrete next steps ('NEXT: get_invoice_line_items({situationKey, whenKey: now})'). The alternative clock tool is named, so the selection condition is unambiguous.

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

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

Annotations only declare readOnlyHint=true, so the description carries real additional weight: it discloses that the payload is a stub pointer rather than page text and that the returned path has the locale prefix stripped. That is meaningful behavioral context an agent cannot get from the annotations alone.

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

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

It is short and front-loads the key caveat, but the telegraphic fragments ('summary says to use ai-pages or HTML') are confusing — they reference an unexplained 'summary' field and an 'HTML' target rather than a tool name, adding ambiguity instead of clarity.

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

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

With an output schema present and only readOnlyHint annotations, the description supplies the critical missing context: this is a pointer, not content, and where to go for content. The main residual gap is that it never states the positive use case for calling this tool at all.

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

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

Schema description coverage is 100%, so the schema already documents path, its default, examples, and the locale enum semantics. The description only repeats 'path optional (default /)' and adds nothing beyond the schema, which is the expected baseline when schema coverage 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 immediately defines the tool as a 'Stub pointer only' and explicitly negates the natural expectation set by the name (it is 'NOT the page body'), then states it returns a path with the locale prefix stripped. That is specific enough to distinguish it from get_ai_page and get_serp_snippet, though 'what a summary actually is' beyond a pointer stays slightly fuzzy.

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 routes the agent elsewhere for real content ('USE get_ai_page or get_serp_snippet for real text'), which is strong negative guidance and names the correct alternatives. It stops short of stating the positive condition under which this tool is the right choice, so it is not a full 5.

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

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

Annotations only cover readOnlyHint=true, so the description carries the meaningful burden and does so: 'formSubmit=false — never claim the form was sent' and 'DOES NOT submit the partner form' actively prevent a hallucinated success claim. 'RETURNS partnerEmail for mailto' discloses the payload shape needed for the next step.

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 labeled WHAT/USE/RETURNS/DOES NOT/NEXT structure that front-loads purpose and routes the agent. Every clause earns its place, and the negative constraint about the form is compactly stated.

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

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

With an output schema present, return-value explanation is not needed, and the description still supplies the one non-obvious output field (partnerEmail) plus the safety-critical negative (no form submission). Nothing required to call and interpret this tool is missing.

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

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

Schema description coverage is 100% and the locale parameter is thoroughly documented there (prefix rules, default, non-effects). The description itself adds nothing about locale, so the baseline 3 applies when the schema does all the work.

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

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

Stated as 'WHAT: Partner-werden page facts', giving a specific resource, and it explicitly draws the boundary against a sibling ('not general contact — that is get_contact'). An agent can tell instantly what this returns and how it differs from get_contact without opening either schema.

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

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

'USE when the user asks about becoming a partner / Partner-werden' names the triggering condition, and '(not general contact — that is get_contact)' names the exclusion and the alternative. 'NEXT: compose_mailto with partnerEmail, or open /partner-werden' closes the loop with follow-on actions.

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 valuable domain-behavior context beyond annotations: it explains that the tool returns a composition structure, that 49 € is already included in larger prices, that night/weekend/holiday rates are different, and that no VAT applies. It does not explain auth or rate limits, but for a read-only informational tool this is a rich disclosure.

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

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

The description is front-loaded with a WHAT section, which helps, but it then becomes a dense jumble of return-value details, domain warnings, contact routing, and VAT notes. Some content, such as the return shape, duplicates what the output schema already provides. It is information-rich but not structured for quick consumption.

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

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

Given the complexity of a price-composition system, the description covers what the tool returns, what it does not do, and which sibling tools to use for related tasks. Because an output schema exists, the description need not explain return values, yet it does so anyway, adding some redundancy. It is complete enough for correct invocation, with minor rough edges.

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 input schema with enum values, default behavior, and URL prefix details. The description does not mention the locale parameter at all, so it adds no meaning beyond the schema. Baseline 3 is therefore 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 that this tool returns the 'Official Festpreis matrix + composition SYSTEM' and clarifies it is to 'understand how to assemble a price.' It distinguishes itself from the sibling get_invoice_line_items by explicitly saying it 'DOES NOT compute one customer total.' However, the purpose is buried in dense jargon and all-caps labels rather than stated as a clean verb+resource, so it falls short of a perfect score.

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 to understand how to assemble a price') and when-not-to-use guidance ('DOES NOT compute one customer total — that is get_invoice_line_items(situationKey, whenKey)'). It also names supporting tools for related tasks: compose_whatsapp/compose_mailto for contact and get_ort_datetime for whenKey. This is exactly the kind of routing information 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?

Annotations only declare readOnlyHint=true, and the description goes beyond that by disclosing the return shape (a pointer, not the body), the error behavior for unknown slugs, and the caller's next step. Useful added context, though it says nothing about pagination, rate limits, or auth needs.

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

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

Labeled WHAT/USE/NEXT/EXCLUSION fragments keep it front-loaded and scannable, and every clause carries information an agent needs for selection or chaining. Zero 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 single-lookup tool with a full schema and an output schema, the description supplies the remaining decision-critical pieces: when to choose it, what happens on a miss, and which tool to call next for the fulltext. 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 description coverage is 100%, so slug provenance and locale semantics (prefix rules, default de, non-effect on prices/legal names) are already fully documented in the schema. The description's 'REQUIRED slug from list_ratgeber' restates what the schema already says and adds nothing for locale, so the baseline 3 applies.

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

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

Opens with a specific verb and resource: 'Returns one Ratgeber page pointer (canonicalUrl /ratgeber/{slug})'. It also explicitly delimits itself against the sibling list_ratgeber ('DOES NOT return the article body here'), so an agent can distinguish it without opening either schema.

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

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

Gives an explicit use condition ('USE when the slug is already known'), an explicit counter-condition with the named alternative ('Prefer list_ratgeber when the slug is unknown'), and a defined failure path ('Unknown slug → unknown_ratgeber (+ hub URL)'). Nothing about routing is left to inference.

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

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

readOnlyHint=true already tells the agent this is a safe lookup, and the description reinforces it by framing the result as redirect URLs. It adds no further behavioral context (no auth requirement, no note on whether the redirect is stable or locale-dependent), but for a trivial read-only resolver the annotations carry most of the burden, so a baseline-plus 3 is appropriate.

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

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

Three clipped labeled clauses (WHAT / RETURNS / USE) are front-loaded and waste no words. Every sentence — including the return-field enumeration and the exclusion — carries information an agent needs to pick and call the tool.

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

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

Output schema exists so return values need not be described, yet the description helpfully names googleReviewUrl and canonicalUrl anyway. With annotations covering safety and the schema covering the only parameter, the definition is essentially complete; the only minor gap is any note on how locale influences the returned canonical URL.

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's enum, default, and prefix semantics are fully spelled out in the schema itself (including that it does not affect prices or phone numbers). The description adds nothing about locale, so the baseline 3 applies.

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

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

States a specific verb and resource ('Short /review redirect to the Google review URL') and two concrete return fields, and explicitly rules out the confusable operation ('Not a list of existing ratings'). An agent can distinguish it from the surrounding get_* content tools without opening the schema.

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

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

'USE when the user wants to leave a review' gives a clear positive trigger, and 'Not a list of existing ratings' provides a negative boundary. However, no sibling alternative is named (there is no reviews-list tool, but resolve_locale_url or list_locales could plausibly be confused context-wise), so it stops just short of a full when/when-not/alternatives treatment.

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

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

With only readOnlyHint=true in annotations, the description carries real weight: it discloses the file-read order and fallback, the path-to-www(locale, path) normalization, the serp_not_found error case, and the return shape (matchContext ~200 before + 400 after, plus source). That is substantial 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?

Front-loads the WHAT, then layers resolution logic, error case, and return shape in dense but ordered fragments. Slightly telegraphic with slash notation, but no sentence 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?

An output schema exists, yet the description still gives the caller the essential fallback and error semantics, and it documents the practical requirement of path/url despite zero formally required params. Nothing critical to correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning: it clarifies that a non-http path is converted to a www(locale, path) URL and that url takes precedence as the search needle when it starts with http. Locale derivation from URL prefix is also explained, exceeding the schema text.

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 ('SERP title/description/URL slice for one marketing URL') and clarifies it reads the llms-serp files rather than a live Google API. This clearly distinguishes it from the raw-file sibling get_llms_serp_txt.

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?

Explains the resolution order (locale file first, then full file), the 'path or url required in practice' constraint, and the no-match behavior. It does not explicitly name an alternative tool for a different need, so it stops 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 only supply readOnlyHint=true; the description carries the rest of the burden and does so well, disclosing that there is no silent Pattonville fallback, the exact failure shape (ok=false, error=unknown_place, hint=/einsatzgebiet), and that each place returns its own unique lat/lng. That is meaningful behavioral context an agent could not get from the 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?

Labeled, front-loaded, and free of filler sentences; the WHAT/USE/NEXT structure scans quickly. It is dense to the point of jargon ('52 unique pairs', 'maps MCP is a second machine') and the latter phrase is unclear, but nothing is truly 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?

With an output schema present the return fields need not be enumerated, yet the description lists them anyway; more importantly it covers lookup order, error behavior, and the follow-up tool, which is what an agent actually needs. The one gap is that it never explains when to prefer this over list_service_areas.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter precedence semantics (slug exact match, else plz match, else name substring) that no individual schema field states. The precedence ordering is genuinely useful for choosing among the three lookup keys.

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?

Opens with a specific verb+resource ('One service-area place') and implicitly separates itself from the sibling list_service_areas by returning a single place. The stated lookup precedence and the enumerated return fields make it unambiguous what the tool fetches.

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, and the NEXT pointer to get_ai_page chains the workflow. It warns against non-existent tool names, but never explicitly contrasts with the real sibling list_service_areas, so routing between the two is left to inference.

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

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

Beyond readOnlyHint=true, it discloses the response shape (summary = line window + trailing # MCP-META with totalUrls, nextOffset, truncated), the windowing/truncation behavior, that 0× maps.ikeytz.com is intentional, and that URL count must be read from MCP-META rather than hard-coded. That is rich behavioral context annotations do not carry.

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-loads 'WHAT:' and the content is high-density, but the mixed German/English phrasing and nested parentheses ('(XML = nur HTML + Brand-Medien, ohne Discovery/Redirect)') make it harder to parse, and the offset/limit paging advice partially duplicates the schema.

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

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

An output schema exists so return values needn't be spelled out, and the description still covers paging, truncation, scope boundary, and the intentional maps omission. Complete enough for an agent to call it correctly, with only sibling-level routing left implicit.

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

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

Schema description coverage is 100% and both params are fully documented there, including the 30KB fallback and nextOffset paging, so the description adds little parameter meaning beyond what the schema already says. Baseline 3 applies.

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

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

States a specific verb+resource ('Fetch /sitemap.txt — KI-Volliste') and enumerates the content classes it covers (HTML ×7 locales + Discovery + Medien + /review). It also explicitly distinguishes itself from sitemap.xml, though it does not differentiate from the closer siblings get_llms_txt / get_ai_txt / get_serp_snippet.

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 concrete operating instructions ('Use offset/limit + nextOffset to page; omit limit for the full list') and a scope boundary ('Dedicated maps list is on maps.ikeytz.com, not here'), plus the sitemap.xml contrast which implies when this list is the right one. No explicit exclusions against the llms/ai txt siblings, so not a 5.

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

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

Annotations only declare readOnlyHint=true, so the description carries real added weight: it discloses that summary contains title plus the first 500 chars of body (truncation), that structuredContent holds only id+title and not the full body, and that an unknown id yields wissen_not_found. These are concrete behavioral traits 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?

Labeled fragments (WHAT / REQUIRED / NEXT) front-load the purpose, required input, output caveat, error case, and follow-up in a handful of words. Every sentence earns its place with no filler.

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

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

An output schema exists, so return values need not be spelled out, and the description still adds the crucial summary-truncation and structuredContent limitations plus the not-found behavior and a next step. 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%, with the id param and the locale enum both fully documented in the schema. The description repeats only that id is REQUIRED and adds no syntax, sourcing, or locale behavior beyond the schema, so the baseline 3 applies.

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

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

The description opens with 'WHAT: One Wissen article', which names the exact resource and its singular scope, implicitly contrasting with the sibling list_wissen. It is clear what the tool fetches, though the verb is implied by the tool name rather than stated.

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

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

The 'NEXT:' clause routes the agent to get_ai_page or the canonicalUrl fragment after a lookup, which is useful follow-up guidance. However, it never states when to call this tool versus list_wissen, find_by_keyword, or get_ai_page — the choice 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.