DRGSystem — German medical coding catalogs

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

Annotations already declare readOnlyHint and idempotentHint; the description adds meaningful behavior beyond that by defining the three output sections, the annual-dose content of focus, and the null-code behavior. It does not cover edge cases like invalid codes or year handling, but output schema and annotations carry the remaining burden.

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 one dense sentence that front-loads the main result ('focus') and packs the remaining output sections compactly. It is efficient and contains no filler, though a short list format would improve scannability.

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

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

For a read-only retrieval tool with an output schema and two optional parameters, the description covers the default behavior, the hierarchy semantics, and the content of the returned records. Nothing an agent needs to decide whether to call it or understand its primary behavior 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 code and year are already documented with examples and default behavior. The description only restates the null-code behavior ('Ohne Kode') that the schema already explains, adding no new parameter-level semantics.

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

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

The description starts with 'Liefert' and names the ATC code, its defined daily dose, and associated ICD diagnoses, and it specifies the hierarchical result sections focus, parents, items. It also states the no-code fallback of returning anatomical main groups, which clearly distinguishes the behavior from the sibling atc_search.

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 implies usage: provide a code to get the code plus hierarchy fragments, or omit the code for top-level groups. However, it never says explicitly when to prefer atc_get over atc_search or other lookup siblings, so the guidance is implied rather than fully stated.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which cover the safety profile. The description adds useful behavioral context beyond those annotations: it clarifies the data source (official ATC classification with defined daily doses) and the result shape (items with DDD and associated ICD codes). No contradiction with annotations exists.

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

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

The description is two sentences with no filler. The action and resource are front-loaded, and both sentences contribute either scope or result-shape information.

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

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

For a read-only search tool with 3 fully documented parameters and an output schema, the description covers the core contract: what is searched, what can be queried, and where results appear. It does not provide explicit routing among the 24 sibling tools, but that gap is captured in the usage guidelines score rather than a fundamental completeness issue.

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

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

Schema description coverage is 100%, and the schema already documents query, year, and limit with examples. The tool description mostly restates that the query can be a code or active ingredient, adding little beyond the schema. The baseline of 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description uses a concrete verb ('Durchsucht') and a specific resource ('amtliche ATC-Klassifikation mit definierten Tagesdosen'), and clearly states the search keys ('nach Kode oder Wirkstoff'). It clearly identifies a search function, but it does not explicitly contrast it with the sibling atc_get tool, so it stops short of full sibling differentiation.

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

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

The description implies when the tool should be used: when looking up ATC codes or active ingredients within the official classification. However, it does not state when to prefer this over atc_get or other classification searches, nor does it mention any exclusions or alternative tools.

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

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

Annotations already declare readOnlyHint and idempotentHint, reducing the burden. The description adds behavioral value by explaining what the response contains (focus, parents, items) and what happens when no code is provided. It does not discuss not-found behavior, but this is a minor gap given the output schema and annotations.

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

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

The description is two sentences with no filler. The core retrieval behavior is front-loaded, and the optional no-code case is stated efficiently.

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

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

For a simple read-only retrieval tool with optional parameters and an output schema, the description is nearly complete. It covers the main behavior, default usage, and return semantics. The only notable gap is not explicitly pointing to dkr_search for free-text lookup scenarios.

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 are already documented with examples and default behavior. The description essentially reinforces the code parameter's default semantics ('ohne Nummer') without adding significant new parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: it retrieves a Kodierrichtlinie and returns its full text, parents, and items. It also defines the no-argument case as returning the top-level structure, which makes the tool's scope clear and distinguishes it from the sibling dkr_search.

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 clearly explains when to call with a code versus without a code, but it does not explicitly mention alternatives such as dkr_search or state when not to use this tool. The usage is implied rather than directly contrasted with sibling tools.

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

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

Annotations already provide readOnlyHint and idempotentHint, covering the safety profile. The description adds useful behavioral context beyond annotations by specifying that hits appear in 'items' and include the full text of each guideline, which helps set expectations without contradicting 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?

The description is compact: two sentences with the action and search scope front-loaded, followed by a useful note about result contents. There is no filler, repetition of annotations, or unnecessary detail.

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

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

For a low-complexity search tool with three fully documented parameters and an output schema, the description covers search scope, query modes, and result shape. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, with clear descriptions and examples for query, year, and limit. The tool description repeats the query semantics ('Nummer oder Text') but adds no parameter detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description starts with the specific verb 'Durchsucht' and names the resource 'Deutschen Kodierrichtlinien (DKR)', stating clearly that search can be by number or text. This distinguishes it from sibling dkr_get and from the other classification-specific search tools.

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

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

The description clearly conveys that the tool is for searching DKR by number or free text and returns full guideline text. It does not explicitly name alternatives or exclusions, but the context is sufficient for an agent to choose it over dkr_get when the exact identifier is unknown or text search is needed.

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

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

Annotations already declare the operation read-only and idempotent, and the description adds substantial behavioral context beyond that: results are delivered in 'focus' and include Bewertungsrelationen, Verweildauergrenzen, Pflegeerlös, Verlegungs-/Wiederaufnahmekennzeichen, full footnotes, and Zusatzentgelte. It also discloses the null-code fallback to the MDC level. No contradiction with annotations.

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

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

Two sentences that are front-loaded with the main action and resource. The long enumeraton is dense but each element describes useful return content, so no sentence or phrase 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?

With an output schema present and read-only/idempotent annotations, the description is complete for the agent's decision: it states what data the tool returns, how to invoke the no-code mode, and what domain it covers. The optional year and code details are already fully documented in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's remark that calling without a code returns the top level mirrors the schema's instruction 'Leer lassen für die oberste Ebene' and adds no new parameter semantics or format details beyond it.

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

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

The description uses a clear, specific verb ('Liefert') with a precise object (all catalog data for a DRG) and enumerates the actual data categories returned. It also clearly explains the no-code behavior (returns the MDC top level), which helps distinguish it from a search tool.

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

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

It gives clear call contexts: with a DRG code to get detailed catalog data, or without a code to get the top-level MDC view. However, it does not explicitly name the sibling 'drg_search' or describe when to prefer that search tool, so it falls just short of full alternative routing.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the search's safety profile is known. The description adds useful behavioral context by explaining that hits appear under 'items' with partition, leading Bewertungsrelation, mean length of stay, and boundary stays, and that drg_get covers the complete values.

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 two sentences with no filler: the first states purpose and search keys, the second states result contents and the alternative for full data. It is front-loaded and every 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?

For a read-only search tool with a full output schema and complete parameter documentation, the description covers scope, result shape, and the relevant alternative drg_get. An agent has enough information to invoke the tool correctly without missing critical context.

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 all three parameters (query, year, limit) already documented including examples and defaults. The description adds no extra parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description starts with a concrete verb 'Durchsucht' and identifies the exact resource, the G-DRG Fallpauschalenkatalog, including the search keys (Kode or Bezeichnung). It also distinguishes the tool from drg_get by stating that complete appendix values are provided there.

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 names drg_get as the alternative when full values of all appendices are needed, giving an agent a clear routing cue. It does not explicitly exclude the other catalog-search siblings, but the resource-specific naming and search-versus-get distinction make the intended context clear.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable behavior beyond annotations by specifying that primary, star, supplementary, and second primary key numbers are all considered. It does not discuss empty-result or error behavior, but the output schema and annotations reduce the burden.

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

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

The description is compact, informative, and front-loaded with the core purpose. The German and English versions partially duplicate each other, but the bilingual structure is deliberate and the key technical detail about key-number types is included without 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 read-only reverse lookup with two well-documented parameters, an output schema, and a clear use case, the description is complete. It covers the essential behavior, scope of results, and practical usefulness, leaving no critical gap for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so both parameters ('code' and 'year') are already documented with format and default semantics. The description only restates the general purpose of the code parameter and adds no format, constraint, or interaction details beyond the schema, which is the expected baseline.

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

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

The description clearly states a specific verb ('Liefert') and resource ('Einträge des Alphabetischen Verzeichnisses'), and defines the operation as a reverse lookup from an ICD-10-GM code to the index terms referencing it. This distinguishes it from the search-oriented sibling icd10alpha_search without requiring schema inspection.

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

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

The description gives clear usage context: use this tool when you have a code and want to know which clinical or everyday terms lead to it. It does not explicitly name alternatives or exclusion conditions, but the reverse-lookup framing makes the intended scenario obvious.

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

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

Annotations already mark the tool readOnly and idempotent; the description adds useful behavioral context by noting that every hit returns primary, asterisk, and additional codes with their official titles from the systematic index. There is no contradiction with annotations.

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

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

The description is front-loaded with the core purpose, followed by explicit usage guidance and alternatives, making it easy to scan. It is slightly longer because of bilingual repetition between German and English, but the content remains purposeful and well organized.

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

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

For a search tool with four documented parameters and an output schema, the description covers the essential context: what to search for, what results look like, and which sibling tools to choose instead. It does not need to explain return values in detail because the output schema exists.

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

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

Schema coverage is 100%, so query, year, limit, and offset are already documented with descriptions, examples, defaults, and ranges. The description adds minor value by emphasizing German-language input and translation, but it does not need to compensate for missing schema documentation.

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

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

The description clearly states a specific verb and resource: it searches the ICD-10-GM alphabetical index and maps clinical or colloquial diagnosis terms to ICD-10-GM codes. It also distinguishes itself from icd10_search and icd10_get, so an agent can tell text-based diagnosis search apart from code-lookup tools.

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

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

It explicitly identifies when to use this tool: as the best first tool when the user asks to find diagnoses by text, symptom, disease name, colloquial German wording, or a partial term. It also names alternatives with the switching condition: use icd10_search when an ICD code is already known and icd10_get for the full entry of one code.

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

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

Annotations already mark the tool as read-only and idempotent, and the description adds meaningful behavioral detail beyond that: it explains the response structure ('focus', 'parents', 'items'), what kinds of content each part contains, and the special no-code behavior of returning the top-level catalog for iterative browsing. This gives an agent a clear mental model of the call's behavior.

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

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

The description is front-loaded with the most important information and clearly structured. It is slightly longer than necessary because the German details are repeated in a condensed English summary, but the bilingual repetition may be intentional and the core behavior remains easy to parse.

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

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

For an optional-parameter read-only lookup with an output schema, the description is fully sufficient: it explains what the tool returns, how the no-code mode works, and where it fits in the search-to-inspect workflow. No critical information for selecting or calling the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, including the null/default behavior of 'code' for the top level and 'year' for the latest available year. The description reinforces the no-code behavior but does not need to add much parameter-level meaning; the baseline of 3 applies.

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

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

The description opens with a specific verb and resource — 'Liefert ... alle Angaben zu einem ICD-10-GM-Kode' — and enumerates the exact kinds of data returned: coding flags, inclusions/exclusions, alphabetical index entries, ATC substances, Morbi-RSA groups, and DKR/SEG-4 references. It also differentiates this get tool from search tools by explicitly positioning it as the tool to call after a search or for top-down catalog browsing.

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

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

The description gives clear usage context: call it after a search to inspect a hit, or call it without a code to browse from the top level. It does not explicitly name the alternative search tools or state when not to use them, but the 'after a search' instruction strongly implies the intended workflow relative to the search siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds valuable behavioral detail: results appear in 'items' as complete catalog rows with multiple listed coding flags (age/sex, CCL, chronic, IfSG, Morbi-RSA, DKR/SEG-4). No contradiction with annotations. It does not over-disclose or need to cover mutating concerns because the tool is read-only.

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 text is front-loaded with the core search purpose and adds sibling routing at the end. It is slightly longer than necessary because the German and English portions partly duplicate the search statement, but every major piece of guidance (result contents, follow-up tool, alternative tool) is present and no filler remains.

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

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

For a read-only search tool with an output schema, the description is complete: it explains what the results contain, when to use this tool, when to use the alpha alternative, and how to get single-code detail. The schema covers the parameters and the output schema covers return structure, so nothing needed for correct invocation is missing.

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

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

Input schema description coverage is 100%, so the schema already documents query, year, and limit. The description only restates that query can be a code or diagnosis text, and the schema already supplies examples like 'E11' and 'Diabetes mellitus Typ 2'. Thus the description adds no significant parameter-level meaning beyond the structured definitions.

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

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

The description names a specific action ('Durchsucht den ICD-10-GM') and a concrete resource, and clarifies how it differs from siblings: it returns full systematic catalog rows and explicitly points to icd10_get for single-code details and icd10alpha_search for natural-language diagnosis wording. This makes the tool distinguishable from nearby search/get tools 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?

It gives explicit routing: use this when an ICD code is already known or systematic rows are wanted; for natural-language wording, call icd10alpha_search first; for inclusions/exclusions/coding notes of a single code, call icd10_get. This is a direct when/when-not statement with named alternatives.

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

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

The annotations already declare readOnlyHint and idempotentHint; the description adds useful behavioral context by explaining the response is delivered in 'focus' and that the result granularity changes with the input code. It does not discuss error/unknown-code behavior, but that is less critical given the read-only, idempotent 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 dense sentences: the first states the resource and delivered data, the second explains the hierarchical input behavior. There is no filler, and the most important information is front-loaded.

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

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

Given the read-only annotations, optional parameters documented fully in the schema, and the presence of an output schema, the description provides enough context for correct invocation. It explains the one non-obvious behavior (level of detail depending on code) and does not need to restate return fields already defined in the output schema.

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

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

With 100% schema description coverage, the schema already documents code and year. The description adds value beyond the schema by explaining that code may be omitted to get federal states and that a state/district key fetches the underlying level, which clarifies the hierarchical semantics.

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

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

The description uses a specific verb ('Liefert') and resource ('Krankenhaus') and lists the delivered fields, making the tool's core purpose clear. It does not explicitly contrast itself with the sibling kh_search tool, so it stops short of full sibling differentiation.

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

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

The description gives clear context for how to navigate the directory: no code returns federal states, state/district keys return the next level down. It does not state when to prefer this tool over kh_search or other siblings, so it lacks explicit alternatives/exclusions.

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 and idempotentHint, so the description does not need to restate safety behavior. It adds useful behavioral context beyond annotations by stating that results appear in 'items' and that detail retrieval requires kh_get. No contradiction with annotations.

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

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

Two sentences, no wasted words, and the most important behavioral information is front-loaded: what is searched, by which criteria, where results appear, and how to get details.

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

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

Given the output schema exists, the annotations cover read-only/idempotent behavior, and all parameters are fully described in the schema, the description is complete for an agent to select and invoke this tool correctly. It also links to the relevant sibling for follow-up detail.

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

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

Schema description coverage is 100%, so the schema fully documents year, limit, and query. The description adds no new semantic detail beyond what the schema already provides for these parameters.

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

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

The description names a specific verb ('Durchsucht'), a specific resource ('Krankenhausverzeichnis'), and the search criteria (IK, Name, Ort). It also distinguishes itself from the sibling kh_get by stating that detailed address/contact information is provided there.

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 sets clear expectations for when to use kh_search versus kh_get: search returns matching list items, while detailed address and contact data come from kh_get for a single hospital. This gives an explicit alternative and the condition that selects it.

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

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

Annotations already signal read-only and idempotent behavior, so the bar is lower. The description adds useful behavioral details: the result appears in 'focus', includes all quality criteria and sub-requirements, is grouped by requirement area, and resolves cross-references in both directions. No contradiction with 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?

Three compact sentences, each earning its place: core deliverable, cross-references resolution, and no-code behavior. The description is front-loaded with the primary verb and resource, with no filler or repetition.

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

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

For a read-only, idempotent getter with two optional parameters and an existing output schema, the description plus schema covers exact-code retrieval, catalog fallback, year selection, and result organization. There is no need for it to explain return values since an output schema is present.

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 code and year parameters are already well documented, including the accepted code forms and default-year behavior. The description only reinforces the null-code fallback, which adds little beyond what the schema already states.

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

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

The description opens with a specific verb and resource: it delivers a Leistungsgruppe nach § 135e SGB V, including quality criteria and sub-requirements, organized by requirement area. It also clarifies the no-code fallback, which helps distinguish this exact-retrieval tool from the sibling lg_search, though it never explicitly names that sibling.

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

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

The description gives clear context for when to leave the code empty: 'Ohne Kode aufgerufen liefert die Funktion die oberste Gliederungsebene.' However, it does not state when to prefer lg_get over lg_search or give any exclusions/alternatives for non-exact lookups, leaving the routing 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 mark the tool as readOnly and idempotent. The description adds useful behavioral context: the output includes the conditions into which the features are decomposed, and the no-code call returns all codes of the year with published features. There is no contradiction with annotations.

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

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

Two sentences, front-loaded with the primary purpose and followed by the no-code variant. Every clause adds value; no filler or redundant wording.

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

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

For a read-only lookup with two optional parameters and an output schema, the description covers the core behavior and the edge mode of omitting opsCode. It could be more explicit about invalid code/year handling, but that is minor given the schema and provided output schema.

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

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

Schema description coverage is 100%: both year and opsCode already have explicit descriptions incluing normalization and null behavior. The description mainly restates the null behavior for opsCode and adds no new param-level semantics beyond the schema.

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

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

The description clearly states the verb ('Liefert') and the exact resource: OPS-Strukturmerkmale checked by the Medizinische Dienst, tied to a specific catalog. This is unique among the sibling tools, making it easy for an agent to distinguish from other get/search operations.

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 explains both invocation modes: with an opsCode it returns the structure features for that code; without one it returns all published codes of the year. It does not explicitly compare against sibling tools, but the usage context is clear and no exclusions are needed.

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

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

The annotations already convey that the operation is read-only, idempotent, and closed-world, so the description does not need to restate safety. It adds the useful detail that hits are returned in 'items', but with an output schema present this is largely redundant and does not disclose deeper behavior such as pagination or matching semantics.

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 short, purposeful sentences: the first states the core search scope, the second adds a valuable use case, and the third points to where results live. There is no filler or repetition.

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

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

For a read-only search tool with full schema coverage, an output schema, and safety annotations, the description carries the right amount of information. It names the resource, the searchable dimensions, a distinguishing use case, and the result container, so an agent has enough to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents the parameters and their meanings. The description broadly clarifies what a query can target (number, name, quality-criteria wording), but it does not add meaningful syntax or format details beyond the schema.

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

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

The description states a specific verb ('Durchsucht'), a clearly defined resource ('Leistungsgruppen nach § 135e SGB V'), and the exact searchable fields (Nummmer, Bezeichnung, Wortlaut der Qualitätskriterien). It also adds a distinct reverse-lookup use case, which helps distinguish it from a plain get-by-id tool like lg_get.

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

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

The description gives clear context for when to use the tool, including the non-obvious reverse question it can answer. It does not explicitly mention when not to use it or point to lg_get for exact single-group lookups, so it stops short of full alternative routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds meaningful behavioral context by stating that all matching entries are returned and that both key number fields of an entry are considered, which goes beyond the schema and 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 sentences, with the core purpose front-loaded and the additional detail about key number fields placed second. Every sentence contributes useful information without 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?

Given the tool's low complexity, the presence of an output schema, and strong annotations, the description is fully sufficient. It tells the agent what is returned, what input is expected, and one important coverage detail without missing any critical guidance.

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

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

Schema description coverage is 100%, so the schema already documents the code format and year behavior with examples. The description does not add extra parameter-level detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Liefert') and a specific resource ('Einträge des Alphabetischen Verzeichnisses'), with a precise selection criterion: entries referencing a particular OPS code. It clearly differentiates the get-by-code behavior from the sibling search tools despite not naming them.

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?

Usage is implied rather than explicit: the description indicates this tool is appropriate when you have an OPS code and want all alphabetical directory entries pointing to it. However, it does not explicitly contrast it with sibling tools like opsalpha_search or state when not to use it.

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

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

Annotations already provide readOnlyHint and idempotentHint, covering safety. The description adds meaningful behavior beyond that: it explains what the Alphabet contains and that each hit already includes the official title from the systematic index. This is useful for an agent deciding whether the returned data satisfies the user's request.

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

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

The description is compact and front-loaded with the action and resource, then the use case, then the result format. Every sentence earns its place, with no repetition of schema details or annotation properties.

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

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

Given the tool has a fully documented 4-parameter schema, an output schema, and safety-relevant annotations, the description is complete. It explains the search scope, the input style, and the informational value of each hit, so an agent has everything needed to use the tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents all parameters clearly. The description adds general context about what sorts of query terms are appropriate ('klinischen und umgangssprachlichen Bezeichnungen'), but it does not add substantial per-parameter meaning beyond the schema.

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

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

The description states a specific verb ('Durchsucht') and a specific resource ('das Alphabetische Verzeichnis des OPS'), and explains that it maps clinical/colloquial procedure terms to official keys. This clearly distinguishes it from systematic-verzeichnis searches and from the sibling opsalpha_get lookup tool.

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

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

The description gives a clear usage context: it is the typical entry point when only the procedure text is known, not a code. It does not explicitly name alternatives or exclusions, but the use-case guidance is strong enough to route an agent appropriately among the sibling search tools.

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

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

The annotations already declare the operation read-only, idempotent, and closed-world; the description adds useful behavioral detail by enumerating the response sections ('focus', 'parents', 'items') and the no-code top-level behavior. This goes beyond what the annotations alone provide, though it does not discuss errors, limits, or special edge cases.

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

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

The description is compact, front-loaded with the primary return value, and every sentence conveys necessary information. The enumeration of returned data is dense but purposeful, and there is no filler.

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

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

For a read-only tool with two optional, fully documented parameters and an output schema, the description is complete. It explains both main invocation modes and the structure of the returned data, leaving no critical gap for correct selection or invocation.

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

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

The input schema covers 100% of the parameter documentation, including the normalization examples and the default behavior for 'code' and 'year'. The description adds little beyond what the schema already states, so the baseline score of 3 is approriate.

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

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

The description clearly states the tool returns all details for an OPS code in 'focus', plus parents in 'parents' and children in 'items', and describes the no-code root catalog behavior. It names the resource and the action precisely, but does not explicitly differentiate itself from sibling tools like ops_search or opsalpha_get, so it falls short of the top 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 clear operating context: pass a specific OPS-Kode to get full details, or omit the code to obtain the top catalog level. It does not, however, provide explicit guidance on when to prefer this tool over alternatives such as ops_search or opsalpha_get.

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 indicate readOnlyHint, idempotentHint, and openWorldHint=false. The description adds useful behavioral context by specifying that results appear in 'items' and what each hit contains, including coding flags, outpatient surgery information, and DKR/SEG-4 references. This goes beyond the annotations without contradicting them.

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 a single, well-structured sentence that leads with the main action and then packs high-value details about what the results contain. No sentence is wasted, and the structure makes it easy to scan.

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

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

Given that the schema fully documents all parameters, annotations cover the safety profile, and an output schema exists, the description is largely complete for invoking the tool correctly. The main gap is the lack of explicit comparison with sibling search/lookup tools, but that is a usage-guidance concern rather than a fatal completeness issue.

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

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

Schema description coverage is 100%, and the schema already documents query, year, and limit thoroughly. The description does not add much beyond the schema for parameter semantics; it restates that query can be a code or text, but that information is already in the parameter description.

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

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

The description clearly states that the tool searches the OPS catalog by code or procedure text, which is a specific verb and resource. It does not explicitly distinguish itself from the sibling opsalpha_search or ops_get, though the emphasis on the main OPS catalog and result contents helps narrow the purpose.

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

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

The description implies when to use the tool: when an agent needs to search OPS codes or procedure texts. However, it does not explicitly state when not to use it or mention alternatives such as ops_get for lookups or opsalpha_search for the alphabetic index, so the guidance is only implied.

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

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

The description goes beyond the readOnlyHint annotation by disclosing the response structure: 'focus' contains the code, 'parents' the ancestors, and 'items' the direct children. It also clearly discloses the default root-level behavior when no code is provided. This is useful behavioral context, though it does not cover error cases or year fallback behavior.

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

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

The description is two sentences long and front-loads the most important information: what the tool returns and how the hierarchy is structured. The second sentence covers the special case of no code. There is no wasted wording.

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 hierarchical catalog lookup tool, the description is complete enough: it explains the main return fields, the meaning of parent and child relationships, and the root-level invocation. The optional parameters are documented in the schema, and an output schema exists, so return value details are covered elsewhere. Minor gaps like invalid-code handling are not essential for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal parameter meaning beyond the schema; it does reinforce that omitting 'code' returns the top level, but it adds no extra detail about 'year' or format expectations. The schema already handles the parameter semantics adequately.

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

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

The description clearly states the tool's purpose: it retrieves a PEPP code along with its parent codes and direct child codes. It also explains the root-level behavior when no code is given. However, it does not explicitly differentiate itself from pepp_search or other sibling tools, so it stops short of full sibling differentiation.

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

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

The description implies the main usage scenario: retrieve a specific code and navigate its hierarchy, or call without a code to get the top level. It provides clear context for how to invoke the tool but does not explicitly state when to prefer this tool over pepp_search or other alternatives.

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

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

Annotations already convey readOnly and idempotent behavior, lowering the bar for the description. The description adds useful behavioral context by stating that hits are returned in 'items' and that matching works on code or designation. No contradiction with annotations.

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

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

Two short sentences: the first delivers the core purpose and expands the acronym, the second states the response container. Every sentence earns its place and the description is front-loaded.

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

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

For a simple search tool with three fully documented parameters, read-only/idempotent annotations, and an output schema, the description is complete enough. The 'items' hint further reduces uncertainty about the result shape, and nothing essential is missing.

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

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

Schema description coverage is 100%: query, year, and limit are all explained in the schema. The description mainly repeats the query semantics (code or designation) and adds no additional meaning for year or limit, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Durchsucht') and resource ('PEPP-Katalog'), and clarifies that searching works by code or designation. It is clear, but it does not explicitly differentiate itself from the sibling pepp_get tool.

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

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

The intended usage is implied: search the PEPP catalog by code or description. However, there is no explicit when-to-use versus when-to-use-an-alternative guidance, such as pointing to pepp_get for direct single-item retrieval.

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

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

Annotations already provide readOnlyHint, idempotentHint, and openWorldHint, so the description does not need to restate safety. It adds useful behavioral detail: the result appears in 'focus', includes code lists and dates, and omitting the code returns the top-level structure. This goes beyond the annotations and does not contradict them.

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 a single focused sentence with no filler. It leads with the primary return value, then the additional contained information, and ends with the fallback behavior. Every clause earns its place.

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

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

For a read-only getter with two optional parameters, an output schema, and annotations covering safety, the description is nearly sufficient. It explains fallback behavior and return contents, and the schema handles year defaults. The only gap is not explicitly routing agents to seg4kde_search when they need to locate a recommendation without knowing its number, but this is not a block to correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the no-number behavior already present in the code parameter's schema description, but it adds little new semantic detail about the year parameter or value formatting. The schema already covers the important defaults, so the description provides adequate but not exceptional parameter context.

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

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

The description states a specific verb ('Liefert') and a specific resource ('SEG-4-Kodierempfehlung'), and details what is returned: full text, publication/modification dates, and ICD/OPS/DRG codes. The no-number fallback to the top-level structure further clarifies the tool's scope. This is clearly distinguishable from sibling search tools because it retrieves a full recommendation rather than searching.

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

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

There is one explicit usage condition: calling without a number returns the top-level hierarchy, and the schema clarifies that leaving year blank uses the latest year. However, the description does not say when to prefer seg4kde_search for finding a recommendation when the number is unknown, nor does it name alternatives or exclusions. The usage context is implied rather than fully explicit.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds that results appear in 'items' and contain the full text plus referenced ICD-, OPS-, and DRG codes, which is helpful context, though it does not disclose additional behavioral traits such as sorting or error behavior.

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

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

The description is two concise sentences. The first states the core purpose, and the second adds useful output information without wasted words.

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 straightforward search tool with a fully documented input schema, safety annotations, and an existing output schema, the description is complete enough. It explains what is searched, what the query can contain, and what the results include, leaving no critical gap for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents 'query', 'year', and 'limit' adequately. The description's mention of 'nach Nummer oder Text' reinforces the query parameter but does not add meaningful detail beyond the schema.

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

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

The description states a specific verb ('Durchsucht') and resource ('Kodierempfehlungen der SEG-4 der MDK-Gemeinschaft'), and explains that search can be by number or text. This clearly distinguishes the search tool from the sibling seg4kde_get, which presumably retrieves a single item.

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 makes the intended use clear: search the SEG-4 recommendations by number or free-text keyword. It does not explicitly name an alternative such as seg4kde_get for exact retrieval, but the get/search sibling pattern and the phrase 'nach Nummer oder Text' provide sufficient context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which covers safety. The description adds useful behavioral detail: the 'focus' output context, the specific fields included, and the special no-code top-level behavior. This goes beyond what annotations provide without contradicting them.

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?

One long but information-dense sentence, front-loaded with the main output ('Liefert in focus alle Angaben zu einem Zusatzentgelt'). Every clause earns its place, though splitting into shorter sentences would improve readability slightly.

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, annotations covering read-only/idempotent behavior, and a description that explains both code-present and code-absent behavior, nothing an agent needs to call this tool correctly is missing.

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

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

Schema description coverage is 100%: both 'code' and 'year' have explicit descriptions and examples in the schema. The description's no-code behavior note is already captured in the schema ('Leer lassen für die oberste Ebene des Katalogs'), so the description adds no extra parameter meaning.

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

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

States a specific verb ('liefert') and a specific resource (Zusatzentgelt), and enumerates the exact data returned (Betrag, OPS-Kodes, ICD-Kodes, Fallpauschalen, Fußnoten). It also distinguishes itself from the ze_search sibling by describing direct get-by-code behavior and the no-code catalog fallback.

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?

Clear context is provided: call with a ZE code to retrieve details, or without a code to get the top-level catalog. It does not explicitly mention ze_search as the alternative for finding codes, so the when-not-to-use guidance is only implied, not stated.

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 read-only and idempotent behavior, so the description need not restate safety. It adds useful output semantics ('items' with amount, origin, and counts of triggering OPS/ICD codes), but it does not describe matching behavior, edge cases, or pagination. Thus it provides some additional context but not extensive behavioral transparency.

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 two sentences, front-loaded with the core search action and query modes, and then gives the relevant result shape. No filler, redundancy, or unnecessary detail.

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

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

For a simple search tool with full schema coverage and an output schema, the description is generally sufficient: it covers searchable inputs and the key result item fields. It lacks explicit sibling routing and some behavioral details, but these are not critical for invoking 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 description coverage is 100%, so parameters are already fully documented (query, year, limit). The description repeats the query semantics with examples but adds no information about year or limit beyond the schema. This fits the baseline 3 for high schema coverage.

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

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

The description uses a specific verb ('Durchsucht') with a clear resource ('Zusatzentgelte-Katalog') and defines the search target ('Kode oder Leistungsbeschreibung'). It clearly distinguishes this search tool from sibling get-tools like ze_get and from searches in other catalogs (DRG, ICD, OPS).

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 implies usage for code or text-based searching of the ZE catalog, but it does not explicitly state when to prefer this over ze_get or any other sibling. There are no explicit when-not-to-use conditions or alternative tool references.

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