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

There are no annotations, so the description carries the burden. It discloses the key output behavior (base64-encoded) and the document-level limitation, but it does not describe error behavior, side-effect profile, or validation behavior. That is a meaningful gap, though the build-and-return phrasing implies a pure function.

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 main action and output encoding, then a compact routing note for the alternative. 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 an 11-parameter tool with full schema coverage and an output schema, the description answers selection, scoping, and return encoding. It does not define 'per-line' or connect to validate_mls_message, but those are minor given the schema and sibling names.

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 description adds no parameter-level detail. Baseline 3 is appropriate because the schema fully documents all 11 parameters and required response codes.

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 ('Build') with a specific resource ('document-level MLS response') and states the return encoding. It explicitly distinguishes this tool from the per-line path by naming the direct builder, so an agent can separate it from siblings like validate_mls_message.

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 scopes the tool to document-level responses and tells the agent to use mcp_einvoicing_core.peppol.mls.build_mls for per-line responses. This is direct when/when-not guidance with an alternative. It could elaborate on per-line terminology, but the routing is unambiguous.

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

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

No annotations are provided, so the description carries full responsibility. It does disclose the core behavior: membership testing against a recognized set of allowance reason codes. However, it does not mention matching semantics such as case sensitivity, trimming, unexpected formats, or what happens for an unrecognized/empty code. The behavior is simple but not fully transparent.

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

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

One sentence with no wasted words. The verb and the object are front-loaded, and the purpose is immediately understandable. This is appropriately minimal for a single-parameter validation 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?

For a simple one-parameter membership check with an output schema, the description covers the essential purpose. The only real gap is not pointing to list_allowance_reason_codes as the source of valid codes, but that is a minor omission given the tool's simplicity.

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 0%, so the description needs to explain the 'code' parameter. It does confirm that *code* refers to an allowance reason code, which adds minimal semantic meaning beyond the parameter name. It does not specify expected format, example values, or that the code should come from the corresponding codelist.

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

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

The description states a specific operation ('check whether code is recognized') against a specific resource ('allowance reason code'). It clearly differentiates from sibling tools like list_allowance_reason_codes by framing this as a validation/verification action rather than enumeration.

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 by 'check whether' — the tool validates a code rather than listing codes. However, the description does not explicitly say when to use it versus list_allowance_reason_codes or whether to use list_allowance_reason_codes first to obtain valid codes. This guidance is missing but not actively misleading.

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 no annotations, the description must carry the behavioral burden. It clearly conveys a read-only predicate check, but does not disclose specifics like return value shape, error behavior, case sensitivity, or codelist version. The core behavior is transparent enough for a simple check.

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, front-loaded sentence with no filler. It states the operation and the parameter context 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 one-parameter predicate tool with an output schema provided separately, the description is largely complete. It names the exact input and the validation action. It could be richer by referencing the list_charge_reason_codes sibling, but that is already covered by usage guidance rather than core callability.

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 only says 'code' is a required string, with 0% description coverage. The description clarifies that the parameter is a charge reason code to validate, adding minimal but useful meaning beyond the schema. It does not provide format, length, or accepted value guidance.

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 ('Check whether') and resource ('charge reason code'), making the tool's purpose unambiguous. It also clearly differentiates from the sibling 'list_charge_reason_codes' by indicating this is a membership validation rather than an enumeration.

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 use is implied: call this when you have a candidate code and need to know if it is recognized. However, the description does not explicitly mention alternatives such as list_charge_reason_codes or state when not to use this tool.

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 no annotations, the description carries the full burden. It clearly states the validation behavior, but does not disclose edge cases such as case sensitivity, whitespace handling, or behavior for non-alpha-2 strings. The output schema may cover return details, but behavioral traits are mostly implied.

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

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

A single, well-structured sentence that immediately communicates the tool's purpose. There is no wasted wording or redundant content.

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

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

For a simple one-parameter validator, the description is nearly complete: it defines the input standard and purpose. The presence of an output schema reduces the need to describe return values. A note on case sensitivity or non-alpha-2 codes would make it fully complete, but this is a minor gap.

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

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

The schema only defines code as a string with no description. The tool description fully compensates by explaining that *code* is an ISO 3166-1 alpha-2 country code, giving the parameter complete semantic 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?

The description states a specific action (check whether) and a well-defined resource (ISO 3166-1 alpha-2 country codes), making it unambiguous. It clearly distinguishes itself from sibling tools like check_currency_code and list_country_codes.

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: use this tool to verify if a string is a valid ISO alpha-2 country code. However, it does not explicitly mention alternatives like list_country_codes for enumeration or say when not to use this tool.

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 no annotations, the description carries the disclosure burden. It does convey read-only validation behavior and the ISO 4217 membership criterion, but it does not state whether an invalid code returns false, raises an error, or how case sensitivity or code format is handled.

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, front-loaded sentence with no filler or redundant information. Every word contributes to understanding the tool's core behavior.

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

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

The tool is simple, has one parameter, and an output schema is present, so return values need not be described. The main gap is the lack of usage guidance relative to sibling list/check tools, but the essential invocation details are clear.

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

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

The schema only defines code as a required string. The description adds meaningful semantics by specifying that the code must be a recognized ISO 4217 currency code. It still does not specify the expected format (e.g., uppercase 3-letter code), but for a single parameter it provides substantial context 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 a specific action ('Check') and resource ('ISO 4217 currency code'), and specifies the criterion ('recognized'). This distinguishes it from sibling tools like check_country_code and list_currency_codes without ambiguity.

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 no guidance on when to use this tool versus alternatives such as list_currency_codes, which could be used to see all valid codes. No exclusions, prerequisites, or alternative recommendations are provided.

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 no annotations, the description carries the transparency burden. 'Check whether' clearly implies a non-mutating validation lookup, but it does not disclose return behavior, error handling, or case sensitivity. Because it is an apparently safe read-only check, the missing detail is notable but not critical.

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 front-loads the action and scope, and every word contributes to the tool's meaning.

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

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

For a one-parameter validation tool with an output schema already present, the description covers the core purpose and parameter semantics. It is slightly incomplete due to the lack of explicit usage or behavior notes, but the low complexity keeps this from being a major gap.

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

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

The schema provides only a raw string property with no description, and coverage is 0%. The description adds essential meaning by identifying code as an UNCL1001 document name code, which compensates for the schema gap even though it does not specify format constraints.

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 and resource: checking whether a code is a recognized UNCL1001 document name code. It clearly distinguishes this from sibling check_* tools by naming the exact codelist standard, and from list_document_name_codes by framing it as a single-code validation rather than enumeration.

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 use is inferable—validate a single UNCL1001 document name code—but the description does not explicitly state when to choose this tool over list_document_name_codes or other check_* siblings. No alternatives or exclusions are mentioned.

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 no annotations, the description carries the behavioral burden and discloses two non-obvious facts: the environment variable requirement and that all codelist states (deprecated/removed) are searched so historical entries are still found. It does not detail behavior on not-found results, but an output schema is provided.

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 sentences with the core purpose first, followed by a prerequisite and a critical behavioral note. No filler or repetition; 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?

The tool has only two plain string parameters and an output schema, so the description need not explain return values. It covers the prerequisite and the one surprising behavior (historical entries count as found); the only minor gap is guidance on where to discover valid scheme/value pairs.

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 0%, so the description must compensate. It adds the meaning that scheme and value together form a document type identifier, but it does not define accepted formats, examples, or where valid values can be obtained. This is partial compensation only.

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 action ('check whether') on a precise resource ('Peppol document type identifier') and clarifies the input is a (scheme, value) pair. This clearly distinguishes it from sibling checkers like check_participant_id_scheme_in_codelist or list_document_type_ids.

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 prerequisite (EINVOICING_PEPPOL_CODELIST_DIR) and references a sibling for context, but does not explicitly say when to prefer this over list_document_type_ids or check_process_id_in_codelist. Usage is implied by the verb and resource rather than stated with alternatives or 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?

No annotations are present, so the description carries the full behavioral burden. The phrase 'Check whether' implies a read-only validation with no side effects, but the description does not disclose edge-case behavior, error handling, or how 'recognized' is determined. It is adequate for a simple predicate but not rich.

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

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

The description is a single concise sentence with no filler. The action and target are front-loaded, making it easy for an agent to quickly understand the tool's function.

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 validation tool with an output schema present, the description covers the essential semantics and operation. It lacks explicit sibling-usage guidance and edge-case behavior, but the tool's simplicity and the presence of an output schema keep it mostly complete.

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

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

Schema coverage is 0% and the schema only defines 'code' as a string. The description adds that the parameter is an Electronic Address Scheme code, which is the key semantic meaning. However, it does not specify format, allowed values, casing, or normalization behavior.

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

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

The description uses a specific verb and resource: 'Check whether *code* is a recognized Electronic Address Scheme code.' This clearly identifies the operation and distinguishes it from sibling codelist check tools for other code types.

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 no guidance on when to use this tool versus alternatives such as list_eas_codes or other check_*_code siblings. It does not state when this validation is appropriate or when another sibling should be preferred.

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 no annotations, the description carries the full behavioral disclosure burden. It conveys that the tool is a read-only validation check, but does not describe error handling, case-sensitivity, codelist version, or side-effect guarantees beyond the implied 'check'. This is minimal but not rich.

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

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

A single sentence with the verb front-loaded and no filler; every word earns its place. The markdown emphasis on code ties the description to the parameter without extra bulk.

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 one-parameter validation tool with an output schema present, the description covers the core operation and parameter meaning sufficiently. It lacks guidance on when to choose list_icd_codes instead and does not mention versioning or edge-case behavior, leaving minor gaps.

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

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

The schema describes the lone parameter only as a string named 'code' with no further explanation. The description adds meaning by specifying the code is an ISO 6523 ICD code to be checked for recognition, which compensates for the 0% schema coverage, though it omits format or examples.

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 operation (check) on a specific resource (ISO 6523 ICD code), which separates it from sibling check_*_code tools that target different codelists such as country or currency codes. The inclusion of the ISO 6523 standard removes most ambiguity about what 'ICD' refers to.

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 use (validate whether a code exists in the ISO 6523 ICD codelist) is implied but not explicitly stated against alternatives. It does not mention that list_icd_codes should be used when the full set of codes is needed, nor does it state any 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It conveys that the tool is a read-only predicate check for code recognition, but it does not say what happens for unrecognized codes or whether the result is a boolean/status, although an output schema exists to cover the return shape.

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

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

The description is a single, clear sentence with no filler or redundant information. The core action and object are front-loaded, making it easy for an agent to parse quickly.

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

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

The tool is simple with one required parameter and an output schema, so the description is minimally viable. However, it lacks any guidance on input format expectations or when to choose this over the sibling list_item_type_codes, leaving a small but real gap for an agent selecting the right tool.

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

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

The schema provides no description for the 'code' parameter (0% coverage), and the tool description only restates that the code is an item type identification code. It adds no format, example, normalization behavior, or accepted value hints beyond what the tool name already implies.

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 ('Check whether') and names a concrete resource ('item type identification code'). It clearly distinguishes this validation tool from the sibling list_item_type_codes and other check_* tools by indicating it tests recognition of a single code.

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 no explicit guidance about when to use this tool versus list_item_type_codes or other check tools. The intended usage is only implied by the tool's name and the phrase 'Check whether', but no alternatives or conditions are mentioned.

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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It conveys the essential trait — this is a read-only validation/lookup with no side effects — and signals the specialized scope of the underlying list (embedded-attachment MIME types, a subset rather than the full registry). However, it is silent on matching semantics such as case sensitivity, exact-match behavior, and how malformed input is handled; the presence of an output schema covers return values but not these call-time behaviors.

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

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

A single sentence with zero filler: it front-loads the action ('Check whether'), binds the parameter (*code*), names the resource (MIME type), and adds the scope qualifier ('for embedded attachments'). Every word earns its place with no redundancy.

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

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

For a one-parameter validation tool with an output schema that covers return values and low overall complexity, the description covers the essential ground: what the tool does, what to pass, and the specialized scope of the codelist. The remaining gaps — no explicit pointer to list_mime_codes and no exact-match or case-sensitivity semantics — are minor given the tool's simplicity.

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 0%, with the lone parameter defined only as a bare string type, so the description must compensate. It does supply the core semantic: the code parameter is a MIME type string from the embedded-attachment registry. It leaves room for improvement by omitting format examples (e.g., 'application/pdf') or any matching constraints.

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 ('check') and identifies the exact resource validated ('a recognized MIME type for embedded attachments'), clearly conveying a membership test. The qualifier 'for embedded attachments' narrows the domain and, with the tool name, differentiates it from sibling check tools for other codelists such as check_country_code and check_currency_code. It stops short of 5 because it does not explicitly position itself against list_mime_codes, its natural sibling alternative.

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 by the consistent list_X_codes / check_X_code sibling pattern: an agent can infer this tool validates a single code while list_mime_codes enumerates valid codes. However, the description never explicitly states when to use this tool over alternatives or mentions that list_mime_codes exists for enumeration, and it gives no exclusions or conditions.

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 no annotations, the description carries the behavioral disclosure burden. It clearly indicates a read-only validation operation and discloses an external dependency: EINVOICING_PEPPOL_CODELIST_DIR must be set. It does not mention failure behavior when the directory is missing, but the output schema covers return structure, so this is a solid level of 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 extremely concise: two sentences with no filler. The core purpose and example are front-loaded, followed immediately by the environment prerequisite. Every sentence adds meaningful 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?

The description covers purpose, input format, and a key prerequisite, and the output schema removes the need to document return values. However, it does not clarify how this tool differs from the sibling check_icd_code or the other codelist checkers, which is a meaningful gap in helping an agent select the right validator confidently.

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

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

The schema provides only the parameter name icd with type string and no description, so the tool description must compensate. It does so by specifying that the value must be a 4-digit ISO 6523 ICD code and giving '0208' as an example, which clarifies format and leading-zero handling. This is strong compensation for the 0% schema coverage, though it could also explain non-recognized/error behavior.

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

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

The description clearly identifies the action: checking whether a 4-digit ISO 6523 ICD code is a recognized Peppol scheme, with a concrete example. It is specific and understandable, but it does not explicitly differentiate this from the closely related sibling check_icd_code, so an agent might not know which validator to choose.

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 usage context is implied: call this when you need to validate a participant ID scheme code against the Peppol codelist. It also provides a useful prerequisite by mentioning EINVOICING_PEPPOL_CODELIST_DIR and pointing to list_participant_id_schemes, but it never states when to prefer this tool over siblings like check_icd_code or the other check_*_in_codelist 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?

With no annotations provided, the description carries the full burden. It clearly signals a read-only membership check against UNCL4461, but it does not state edge-case behavior such as how unrecognized codes are handled, case sensitivity, or whether invalid input returns false versus raising an error. The output schema may clarify return shape, but behavioral details beyond a simple predicate are not disclosed.

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

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

A single sentence with no filler. The key information—the code to check and the codelist standard—is front-loaded, and every word contributes to the purpose. This is appropriately concise for a simple validation 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?

For a single-parameter predicate with an output schema, the description is mostly adequate: it names the input and the codelist standard. However, it lacks any usage context, guidance on alternatives, or note on error/edge-case behavior, so an agent would still need to make assumptions about how to invoke it correctly in a broader workflow.

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 0%, so the description must compensate. It does add meaning by tying the generic 'code' property to a UNCL4461 payment means code, which is essential context. However, it does not describe format, length, case sensitivity, or accepted variants, leaving the parameter only minimally documented.

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 ('check whether') and names the exact resource (UNCL4461 payment means code), making the tool's membership-test purpose unambiguous. It also distinguishes itself from sibling list_payment_means_codes, which would enumerate the same codelist rather than validate a single code.

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 no guidance on when to use this tool versus sibling alternatives such as list_payment_means_codes or other check_* validation tools. Usage is only implied by the word 'check', so the agent must infer the validation-vs-listing distinction without explicit direction.

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 no annotations, the description carries the burden of behavioral disclosure. It does disclose an important external dependency (EINVOICING_PEPPOL_CODELIST_DIR), which is valuable. However, it does not mention failure behavior or what happens when the environment variable is missing, and it leaves return semantics to the output schema.

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

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

The description is two concise sentences with no filler: the first states the tool's purpose and the second adds the key prerequisite. The essential 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?

For a simple two-string codelist check with an output schema, this is minimally adequate: it gives purpose and dependency. But it lacks a pointer to list_process_ids for retrieving valid identifiers and provides no detail about valid scheme/value forms, leaving the agent to infer important 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 0%, so the description needed to explain the parameters. It only restates that the input is a '(scheme, value) pair' and labels it a process identifier, without explaining valid scheme formats, value formats, or how to discover valid process IDs. This is insufficient compensation for the missing schema descriptions.

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

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

The description uses a specific verb ('Check whether') and a specific resource ('Peppol process identifier'), and clarifies that the input is a (scheme, value) pair. This makes it easy to distinguish from sibling check_* tools that target participant IDs, document types, and other codelists.

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

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

The description provides a useful prerequisite (EINVOICING_PEPPOL_CODELIST_DIR) and points to list_participant_id_schemes, but it does not explicitly explain when to choose this tool over list_process_ids or the other check_* tools. The intended usage is implied by 'Check whether', not stated as a decision rule.

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

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

With no annotations, the description needs to disclose behavior. It clearly indicates a non-destructive validation check and identifies the codelist, which is good. However, it does not mention side effects, exact-match semantics, or what happens for invalid codes; the output schema is available but not described here.

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

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

The entire description is one front-loaded sentence with no filler. It directly states the verb, object, and codelist, making it maximally efficient.

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

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

For a one-parameter validation tool with an output schema available, this description is largely complete: it identifies the input, the target codelist, and the check being performed. It lacks usage context relative to sibling list/check tools, but that is covered under usage guidelines; the invocation itself is adequately 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 0% and the parameter is simply a string named 'code'. The description adds crucial meaning by explaining that this is a UNCL1153 reference qualifier code, which tells the agent exactly what value to supply. It does not provide format examples, but the semantic intent is clear.

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 ('Check') and states the resource precisely: whether a code is a recognized UNCL1153 reference qualifier code. This distinguishes it from sibling tools like check_country_code and list_reference_qualifier_codes because it names the exact codelist and operation.

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?

No guidance is given about when to use this tool versus alternatives, such as list_reference_qualifier_codes. The description merely states what it does, so the agent must infer usage from naming conventions rather than from any explicit 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?

No annotations are provided, so the description carries the behavioral burden. The verb 'check' signals a read-only, non-mutating lookup, and the reference to UNCL5305 defines the recognition standard. Returning the result is covered by the output schema, so no further behavioral detail is essential.

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. The key predicate and standard are stated upfront, making it easy for an agent to parse quickly.

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?

This is a low-complexity tool with one required string parameter and an output schema present. The description, combined with the schema, provides everything an agent needs 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?

The input schema gives only a bare 'string' type with 0% description coverage, but the description fully explains that 'code' is the candidate UNCL5305 VAT category code to validate. This fully compensates for the schema's lack of parameter 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 states a specific verb ('check') and resource ('UNCL5305 VAT category code'), making the tool's purpose immediately clear. It is easily distinguished from the sibling list_vat_category_codes, which lists codes rather than validating a single one.

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 implies the intended use case: validating whether a single code is a recognized VAT category code. It does not explicitly name alternatives or exclusions, but for a simple predicate tool the context is sufficiently 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?

No annotations are provided, so the description is the only behavioral disclosure. It accurately conveys a non-mutating membership check, but it does not explain input handling details such as case sensitivity, normalization, or how invalid or unrecognized codes are represented. These gaps prevent a higher score.

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 clear sentence with no repetitive or extraneous content. The action and subject are front-loaded, making the tool's purpose immediately understandable.

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 validation tool with an output schema, the description provides the essential purpose and parameter meaning. The main missing piece is explicit routing to list_vatex_codes or other related tools, but the simplicity of the check makes the definition largely complete.

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

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

The schema only defines 'code' as a string with no description, so the description adds meaningful domain context: the code is a VATEX VAT exemption reason code and is tested for recognition. It does not provide format or examples, but the single parameter is scoped well enough for correct invocation.

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 precise action, 'Check whether,' and a specific resource, a recognized VATEX VAT exemption reason code. It clearly distinguishes this from list_vatex_codes and other check_* sibling tools by naming the VATEX domain and the membership-test behavior.

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 by saying 'Check whether *code* is recognized,' but it does not explicitly mention alternatives such as list_vatex_codes for enumerating valid codes or state when not to use this tool. An agent must infer the appropriate context from the name and sibling pattern.

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 no annotations provided, the description carries the full burden. It discloses the core transformation ('maps invoice line items to DATEV booking records') and the output ('Produces a CSV file'), but does not explicitly mention side effects, read-only status, permissions, or error conditions. The description does not contradict any 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 fluff. The first sentence front-loads the exact purpose, and the second sentence adds value by explaining the output format and mapping behavior. Every word 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 6-parameter tool with a nested invoice object and an output schema, the description is sufficiently complete: it names the target format, the importing software, and how line items are transformed. Minor gaps such as explicit error handling or read-only status are not critical given the structured metadata that exists.

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

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

Schema description coverage is 100%, so the schema already fully documents all six parameters. The description adds the phrase 'configurable accounts,' which maps to the account parameters, but it does not meaningfully extend the schema's parameter explanations.

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: 'Export a ZUGFeRD invoice to DATEV CSV format (EXTF 700, Buchungsstapel).' This clearly identifies what the tool does and distinguishes it from generic invoice tools like invoice_convert or invoice_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 states the output is 'importable by DATEV Belegtransfer or DATEV Rechnungswesen', giving clear context for when an agent should use this tool. However, it does not explicitly compare to alternatives like invoice_convert 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?

There are no annotations, so the description must carry the behavioral burden. 'Report' signals a read-only informational action and 'configured locally' suggests no network or remote lookup, which is useful. However, it does not explicitly state that the tool has no side effects, never modifies state, or what kind of value(s) will be returned, though the output schema partially covers return shape.

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

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

The description is a single, compact sentence with no redundant or vague wording. It front-loads the action and resource, and every word contributes to understanding what the tool does.

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

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

For a zero-parameter, locally scoped read-only reporting tool with an output schema, the description is fully sufficient. It names the exact codelist, the version scope, and the local context. The presence of an output schema means return-value details do not need to be restated in the description.

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

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

The tool has zero parameters and the schema documents that with an empty properties object and additionalProperties false, giving 100% schema coverage. Since there are no parameters to explain, the description does not need to add 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 uses a specific verb ('Report') with a precise resource ('CEF EN 16931 code-list release version(s)') and a scope qualifier ('currently configured locally'). It clearly distinguishes this from the sibling get_peppol_codelist_version by naming the EN 16931 codelist rather than a generic or PEPPOL codelist.

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 phrase 'currently configured locally' implies the tool is for checking local configuration, but there is no explicit guidance about when to choose this over get_peppol_codelist_version or any other sibling. No exclusions or alternative conditions are stated, so usage is only implied rather than clearly directed.

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 no annotations provided, the description carries the behavioral disclosure burden. It does so reasonably by stating the tool reports locally configured versions, which implies a read-only local lookup and no external network dependency. It does not explicitly mention side-effect safety, but the verb 'Report' and the local scope make the read-only nature clear enough.

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, front-loaded sentence with no filler or redundant information. Every word contributes to identifying what the tool does and where it operates.

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

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

For a zero-parameter local lookup tool with an output schema available, the description is complete. The agent can invoke it correctly without needing additional parameter details, and the local scope is explicit.

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 is empty with zero parameters, so the baseline of 4 applies. There are no parameter semantics to clarify, and the description's mention of the resource and scope is sufficient.

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 identifies the operation as reporting the OpenPeppol eDEC code list release version(s) and scopes it to the local configuration. This distinguishes it from the sibling get_en16931_codelist_version by specifying a different code list family.

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 no explicit guidance on when to use this tool versus alternatives such as get_en16931_codelist_version. It only implies that it is appropriate when the locally configured OpenPeppol eDEC version is needed, with no exclusions or alternative routing.

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

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

With no annotations provided, the description carries the full behavioral burden and does well: it explicitly discloses the risk of data loss on downgrades, explains the allow_data_loss flag's effect, notes that discarded fields are listed in the output, and states that conversion is rejected if data loss would occur while the flag is False. This is strong behavioral 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 compact and front-loaded with the core action, followed by supported transformation types and a critical cautionary note. Every sentence earns its place; there is no fluff 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?

The tool is complex, but the schema covers all parameters at 100%, an output schema exists, and the description covers the key behavioral caveat (data loss). The agent gets everything needed to decide whether conversion is appropriate and how to handle lossy downgrades. No critical gap is apparent.

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 does not add much beyond the schema: it restates the data-loss behavior already described for allow_data_loss but doesn't clarify input selection between xml_base64 and xml_content or other parameter nuances. It neither compensates for gaps nor introduces redundant detail.

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 'Convert' with a clear resource ('ZUGFeRD or XRechnung invoice') and a precise target ('different profile or syntax'). It distinguishes itself from siblings like invoice_create, invoice_validate, and invoice_parse by focusing solely on transformation rather than creation, validation, or parsing.

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

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

The description provides clear context on when to use this tool: for profile upgrades/downgrades, ZUGFeRD <-> XRechnung conversion, or CII <-> UBL transformation. It does not explicitly name alternative tools or exclusion conditions, so it stops short of a perfect score, but the usage context 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does this well by explaining that non-XML output is rejected unless transitional_period_opt_in is set, and by specifying the legal mandate for German VAT-registered buyers. It could go further by noting expected error behavior or side effects, but for a generation tool the compliance constraints are the most important behavioral traits and they are explicit.

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 despite covering a legally complex topic. It front-loads the core purpose, then layers profile support, syntax guidance, and legal constraints in a logical order. The legal citations add necessary authority for a compliance-sensitive tool, and 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?

Given the complexity of invoice generation, the description covers the key decision points: format, profile, syntax, and legal opt-in conditions. The output schema and 100% parameter coverage fill in the technical return details. It is slightly less complete on alternative-tool routing, but overall it provides enough context for an agent to invoke invoice_create correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful context beyond the schema: it enumerates supported ZUGFeRD profiles, explains the XRechnung syntax choice, and clarifies when transitional_period_opt_in should be true. This helps an agent reason about the invoice.profile and output_format parameters rather than just reading their schema descriptions.

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

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

The description opens with a specific verb and resource: 'Generate a ZUGFeRD 2.x or XRechnung 3.x invoice in XML (CII or UBL) format.' It clearly names the formats and profiles, and the generation verb distinguishes it from siblings like invoice_validate, invoice_parse, and invoice_convert. No ambiguity remains about what this tool does.

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: how to select XRechnung, which profiles are supported, and when the transitional_period_opt_in flag is required for non-XML output. It does not explicitly list when not to use this tool or point to alternatives, but the sibling names and the creation-focused wording make those boundaries reasonably 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 no annotations provided, the description carries the behavioral transparency burden. It discloses meaningful behavior: for PDFs, the XML is extracted from the PDF/A-3 attachment, and the output matches the invoice data model. It does not mention error behavior or what happens when multiple inputs are supplied, but for a parsing operation the key behaviors are adequately surfaced.

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 three dense sentences: purpose, accepted inputs, output. Every sentence adds a distinct fact, there is no boilerplate, and the most important verb/object combination 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?

The description covers accepted formats and result shape, and the output schema handles return values. The main gap is that all params are optional in the schema, yet the description implies at least one input should be provided; it never explicitly states that exactly one input source is required or what happens if multiple are passed. This is a moderate completeness issue 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%, and each parameter already has a meaningful description. The tool description restates the input format categories in prose but adds no semantic detail beyond the schema, so the baseline score 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: 'Extract structured data from a ZUGFeRD 2.x or XRechnung 3.x invoice.' This clearly identifies the tool's parsing function and distinguishes it from siblings like invoice_validate or invoice_convert, which have different purposes.

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 by enumerating accepted input forms (raw XML, base64 XML, base64 PDF) and the output type (structured JSON), so an agent can tell when this tool fits. However, it does not explicitly contrast with alternatives such as invoice_validate or invoice_convert, 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?

With no annotations, the description carries the behavioral disclosure burden and does it well by warning that cloud_validate=True 'egresses the full invoice payload' and noting the default is local-only. It also discloses the structured report output. It does not mention fallback or error behavior, but those are covered in the schema descriptions.

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

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

The description is well-structured and front-loaded: core action first, then rules, return value, supported formats, and operational behavior. Every sentence adds necessary information without fluff, making it easy to scan and use.

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

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

The description covers supported standards, validation rules, profile/syntax auto-detection, local/cloud behavior, and the data-egress caveat. Combined with a fully self-describing schema and an output schema, an agent has everything needed 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 description coverage is 100%, and each parameter already has a detailed explanation, so the baseline is 3. The main description adds one extra piece of information not in the schema (the EINVOICING_DE_KOSIT_ENABLE=1 environment variable) but otherwise does not materially extend parameter semantics.

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

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

The description opens with a specific verb and resource: 'Validate a ZUGFeRD 2.x or XRechnung 3.x invoice XML.' It further specifies the validation rules, supported profiles, and return type, making it clearly distinct from sibling tools like invoice_parse, invoice_create, or validate_eusr_report.

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 identifies the intended input (invoice XML) and scope (ZUGFeRD/XRechnung, EN 16931, KoSIT rules), and explains auto-detection and default local execution. It does not explicitly name sibling validation tools as alternatives, but the strong 'invoice XML' framing plus sibling names provide enough context for an agent to choose correctly.

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?

No annotations are present, so the description carries the behavioral disclosure burden. It communicates that the tool lists codes and identifies the code list source, but it does not explicitly state that the operation is read-only, whether it returns all codes, or whether the list depends on a particular code-list version. The 'List' verb makes the read-only nature reasonably inferable.

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, front-loaded sentence with no filler, repetition, or unnecessary details. Every word contributes meaning.

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

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

For a parameterless list tool with an output schema, the description is largely complete: it precisely identifies what is listed and from which standard. The only minor gap is that it does not mention code-list versioning or point to check_allowance_reason_code for single-code validation, but these are not required 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?

The input schema has zero parameters and schema description coverage is 100%, so there is no parameter documentation burden for the description. The baseline for zero-parameter tools is 4, and the description adds relevant source context beyond the empty 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 ('List'), a specific resource ('allowance reason codes'), and the source ('CEF EN 16931 code list'). This clearly differentiates it from sibling tools like check_allowance_reason_code (check vs. list) and list_charge_reason_codes (allowance vs. charge).

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 does not explicitly state when to use this tool versus alternatives, nor does it mention check_allowance_reason_code. However, the verb 'List' and the resource name imply the intended use case: retrieving the full set of allowance reason codes rather than validating a single 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?

No annotations are provided, so the description carries the disclosure burden. 'List ... from the CEF EN 16931 code list' clearly conveys a read-only retrieval operation from a specific authoritative source. There are no parameters or side effects to disclose, and the description is honest about what the tool does.

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, front-loaded sentence with no filler. It states the action, the object, and the source without 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 parameterless list tool with an output schema present, this description is complete. It identifies the exact resource and source, and the output schema covers return-value details. Nothing needed for correct invocation is missing.

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

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

The tool takes zero parameters, so there are no parameter semantics for the description to clarify. The schema fully covers this, and the description's mention of the CEF EN 16931 code list provides useful context without needing to describe 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?

The description states a specific verb ('List'), a clear resource ('charge reason codes'), and a source ('CEF EN 16931 code list'). This cleanly differentiates it from sibling check functions like check_charge_reason_code and other code-list listings.

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 verb 'List' implies this tool is for retrieving the full set of charge reason codes, and sibling names suggest the complementary check tool, but the description does not explicitly say when to use this tool over check_charge_reason_code or other alternatives. Usage is implied rather than 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?

With no annotations provided, the description carries the behavioral disclosure burden. 'List' makes the read-only nature clear, and naming the ISO standard and CEF EN 16931 source adds useful context about the data. No hidden side effects or surprising behavior are evident for this zero-parameter listing operation.

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 concise sentence with no filler. Every word contributes: the action, the code standard, and the source list are all present and 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 zero-parameter list tool with an output schema available, the description is largely complete: it states exactly what will be listed and from which source. A small gap is the lack of explicit guidance on when to choose this over check_country_code, but this is a minor omission for such a simple operation.

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 has zero parameters and schema description coverage is 100%, so there is no parameter meaning to add. The baseline for a no-parameter tool is 4, and the description appropriately focuses on what is returned rather than 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?

The description uses a specific verb ('List') with an exact resource ('ISO 3166-1 alpha-2 country codes') and a clear source ('CEF EN 16931 code list'). This clearly distinguishes the tool from siblings like check_country_code, which validate individual codes rather than listing 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?

The intended use is implied by the verb and resource: use this when a list of country codes is needed. However, the description does not explicitly contrast it with alternatives such as check_country_code or discuss when not to use it, so some guidance is left to inference.

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

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

With no annotations, the description carries the behavioral burden. 'List' clearly signals a read-only operation, and specifying the CEF EN 16931 code list adds meaningful source context. The zero-parameter nature and output schema reduce the need for further detail.

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

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

A single, well-structured sentence that starts with the action and directly states the resource and source. There is no redundant wording or 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 zero-parameter, read-only list operation with an output schema, the description is fully sufficient. An agent can invoke this tool without ambiguity or missing prerequisites.

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

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

The tool has zero parameters, so there is no parameter semantics burden. The baseline of 4 applies because the description needs to explain no inputs, and it does so implicitly by being a simple listing operation.

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

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

The description states a specific verb ('List'), a clear resource ('ISO 4217 currency codes'), and a precise source ('CEF EN 16931 code list'). This clearly differentiates it from sibling tools like check_currency_code and list_country_codes.

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 its use for retrieving all currency codes but provides no explicit guidance on when to choose this tool over check_currency_code or other list tools. No exclusions or alternative routing are mentioned.

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 no annotations, the description carries the burden of explaining behavior. It clearly conveys a read-only listing operation with a defined source, so an agent can infer there are no side effects. It does not mention ordering, size, or pagination, but the operation is simple, parameterless, and backed by an output schema.

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

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

The description is a single, well-structured sentence with the action verb front-loaded. It contains no filler or redundant restatement of the tool name.

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

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

For a parameterless listing tool with an output schema, the description is nearly complete: it identifies the exact standard and resource. It could optionally mention the check counterpart, but that omission does not seriously impair usability.

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 has zero parameters and complete coverage, so the description does not need to explain parameters. The description adds useful context about the code list source, which is appropriate for a parameterless tool.

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

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

The description states a specific verb ('List') applied to a clearly identified resource ('UNCL1001 document name codes from the CEF EN 16931 code list'). This makes the tool's purpose immediately recognizable and distinct from sibling check-type tools such as check_document_name_code.

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 use when an agent needs a full enumeration of document name codes, but it does not explicitly state when to prefer this over check_document_name_code or another alternative. No exclusions or alternative-tool guidance is provided.

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 no annotations, the description carries the burden of behavioral disclosure. It reveals a critical runtime dependency (the environment variable) and directs the agent to a sibling for setup. For a read-only list operation, this is meaningful and sufficient 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 with no filler. The core purpose is stated first, and the prerequisite is appended as a useful, terse second sentence.

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

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

For a simple list operation with one optional parameter and an output schema, the description covers what is listed, the source, and the setup requirement. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the single parameter active_only is fully documented there. The description adds no additional parameter semantics, which is acceptable because the schema already explains the behavior.

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

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

The description uses a specific verb ('List') and a precise resource ('Peppol document type identifiers'), and identifies the source ('OpenPeppol eDEC code list'). This clearly distinguishes it from sibling list tools such as list_document_name_codes.

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 a concrete prerequisite, EINVOICING_PEPPOL_CODELIST_DIR, and points to list_participant_id_schemes for setup. It does not explicitly contrast this tool with check_document_type_id_in_codelist, but the list/check naming makes the distinction reasonably 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 no annotations, the description carries the burden of behavioral disclosure. It adds the context that the codes come from the CEF EN 16931 code list and the read-only 'List' verb, but it does not describe output behavior such as whether all codes are returned at once or whether they are ordered. The output schema partially compensates for the return format.

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

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

The description is a single front-loaded sentence that defines the resource and source without filler. Every word contributes to the meaning.

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

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

For a zero-parameter list operation with an output schema, the description is sufficiently complete: it names the exact code list and resource. It could be slightly fuller by pointing to check_eas_code for validation, but that is a usage-guidance refinement rather than a blocking gap.

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

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

The tool has no parameters, so the description has no parameter semantics to explain. This matches the baseline for a zero-parameter tool.

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

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

The description names a specific verb ('List'), a precise resource ('Electronic Address Scheme (EAS) codes'), and a data source ('CEF EN 16931 code list'). This clearly distinguishes it from the sibling check_eas_code, which validates a single code rather than enumerating the code list.

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 purpose of listing EAS codes implies when the tool is appropriate, and the sibling check_eas_code provides a contrasting validation use case. However, the description does not explicitly state when to choose this tool over check_eas_code or mention any 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?

With no annotations provided, the description carries the behavioral disclosure burden. The verb 'List' and the fixed source imply a read-only enumeration with no side effects, which is sufficient for a parameterless list operation. It does not detail ordering or filtering, but the presence of an output schema covers return structure.

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

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

A single sentence with no filler: verb, object, and source are all present and front-loaded. Every word 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?

Given the tool's simplicity (no parameters, output schema provided), the description is nearly complete. It names the code list and source. The only missing context is usage guidance relative to sibling check/list tools, which is already penalized in the usage dimension.

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 has zero parameters, so the description does not need to explain parameter meaning. The '0 params = baseline 4' rule applies; the description correctly implies no inputs are required.

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

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

The description states a specific action ('List') and a precise resource ('ISO 6523 ICD codes') with a source ('CEF EN 16931 code list'). It clearly distinguishes from sibling list tools like list_eas_codes and check_icd_code by naming the exact code category.

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 no explicit when-to-use guidance or alternatives. An agent must infer from naming conventions that check_icd_code is for verifying a single code and list_icd_codes is for enumerating all ICD codes. No exclusions or conditions are mentioned.

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?

No annotations are provided, so the description carries the full burden. It discloses the read-oriented 'List' behavior and names the data source, which is helpful. It does not explicitly state that this is a read-only operation, whether it requires authentication, or how the returned list behaves beyond the existence of an output schema.

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

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

The description is a single, front-loaded sentence with no filler: 'List item type identification codes from the CEF EN 16931 code list.' Every word contributes meaning, and the action and resource are clear immediately.

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

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

For a zero-parameter listing tool with an output schema present, the description provides enough context: it names the action, the resource, and the code-list source. It leaves implicit the relationship to check_item_type_code, but the tool's simplicity reduces the need for additional 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?

The input schema has zero parameters and 100% schema description coverage, so there are no parameters needing further explanation. According to the baseline for zero-parameter tools, this is appropriately handled.

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 'List' and the resource 'item type identification codes', and adds the source 'CEF EN 16931 code list', which is specific and useful. It does not explicitly name the sibling tool check_item_type_code, but the resource is distinct enough to avoid confusion with other list_* tools.

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

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

The description implies this tool is for enumerating item type codes from a standard code list, and the sibling check_item_type_code implies the check alternative. However, it does not explicitly state when to prefer this tool over check_item_type_code or any other list_* tool, so the usage guidance remains implicit.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It conveys that this is a read-only listing operation through the verb 'List' and scopes the result to 'recognized MIME types for embedded attachments,' but it does not disclose additional behavioral traits such as whether the list is static, sorted, paginated, or subject to any restrictions.

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 of eight words with no filler. It leads with the verb 'List,' immediately stating the action, and every word ('recognized,' 'MIME types,' 'embedded attachments') adds relevant scoping.

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

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

For a zero-parameter tool with an output schema, the description is mostly adequate, but it does not explain how this list tool relates to its sibling check_mime_code or whether the MIME types come from a specific standard or codelist. The output schema covers return values, yet the description omits the broader context needed for an agent to decide when to call it.

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

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

The tool has zero parameters, so the input schema is trivially complete and the description correctly implies no arguments are needed. The baseline for a no-parameter tool is 4, and the description adds no conflicting or unnecessary parameter information.

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 action ('List') and resource ('recognized MIME types'), scoped further by 'for embedded attachments.' It is specific enough to be understood on its own and is implicitly distinct from the sibling check_mime_code, though it does not explicitly name that alternative.

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

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

The description provides no guidance on when to use this tool versus alternatives such as check_mime_code. There is no mention of 'use this to get the full list' or 'use check_mime_code to validate a single code,' leaving the agent to infer the differentiation solely from the tool name and sibling 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?

With no annotations, the description carries the behavioral burden. It meaningfully discloses that the tool depends on a local, non-bundled GeneriCode export via an environment variable, which is important failure context. It does not discuss error behavior or explicitly affirm read-only semantics, but 'List' makes the operation reasonably clear.

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

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

The description is compact and front-loaded: the purpose appears in the first sentence, and the environment prerequisite and redistribution caveat appear in the second. Every clause earns its place, and the pointer to the module docstring is useful rather than 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 one-parameter list operation with an output schema, the description plus schema fully covers purpose, the single parameter, and the required environment setup. Nothing essential is missing for an agent to decide whether to call this tool and what precondition must be met.

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 both parameters effectively: there is only active_only, and it has a clear description. With 100% schema description coverage, the description does not need to add parameter semantics, so the baseline score of 3 applies.

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

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

The description states a specific verb ('List'), a specific resource ('Peppol participant identifier (ICD) schemes'), and a source ('OpenPeppol eDEC code list'), so an agent can tell this apart from the sibling check tool. It does not explicitly name a sibling, but the resource phrasing is specific enough to avoid obvious confusion with list_icd_codes or list_eas_codes.

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 operational context by requiring EINVOICING_PEPPOL_CODELIST_DIR to point at a local copy of the eDEC export, which is useful when deciding whether the tool is callable. However, it does not explicitly say when to prefer this tool over siblings such as check_participant_id_scheme_in_codelist or list_icd_codes; usage is mostly implied by the verb and resource.

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?

No annotations are provided, so the description carries the behavioral disclosure burden. It indicates the tool is a read-only listing operation and names the source code list, but does not disclose pagination, error behavior, or return size. Since there are no parameters and an output schema exists, the missing behavior details are relatively minor.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word adds meaningful information: the operation, the code standard, and the source list.

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

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

For a simple, parameterless enumeration tool with an output schema, the description is nearly complete. It could strengthen routing by explicitly naming the sibling check tool, but the core information needed to select and invoke the tool 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?

The tool has zero parameters and the schema fully documents this (100% coverage), so there is no parameter ambiguity. The description adds useful source context ('CEF EN 16931 code list') that helps the agent understand the domain, even though parameter-level semantics are not applicable.

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 ('List') and resource ('UNCL4461 payment means codes from the CEF EN 16931 code list'), which clearly states what the tool returns. It also naturally contrasts with the sibling 'check_payment_means_code', making the distinction between listing all codes and checking a single code evident.

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: call this when you need the full list of UNCL4461 payment means codes. However, it does not explicitly mention alternatives or when not to use it, such as indicating that 'check_payment_means_code' should be used to verify a specific 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?

With no annotations provided, the description carries the behavioral disclosure burden. It clearly indicates a read-only listing operation and reveals the required environment variable, adding useful context beyond the tool name. It does not describe error behavior if the environment variable is missing, but that is a minor gap for a simple read tool.

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

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

Two sentences with no filler. The primary action is front-loaded, and the prerequisite cross-reference is placed second, making the description 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?

For a simple list tool, the description covers the data source and a required setup step, and the output schema covers return values. The only notable gap is the lack of explicit guidance on when to choose this tool over the check_process_id_in_codelist sibling, but overall the context is sufficient.

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

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

Schema description coverage is 100%; the only parameter active_only already has a clear description in the schema. The tool description adds no additional meaning about parameters, which matches the baseline expected when the schema fully documents 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 uses the specific verb 'List' with a clear resource: 'Peppol process identifiers from the OpenPeppol eDEC code list.' This distinguishes it from sibling tools like check_process_id_in_codelist, which verifies a single identifier rather than listing 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?

The description states a prerequisite (EINVOICING_PEPPOL_CODELIST_DIR) and points to list_participant_id_schemes for context, which gives some usage guidance. However, it does not explicitly explain when to use this tool versus the sibling check_process_id_in_codelist or other list tools, leaving the selection 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 no annotations provided, the description carries the burden of behavioral disclosure. The verb 'List' clearly signals a read-only retrieval operation, and the data source is precisely identified. The description does not mention potential side effects because for this zero-parameter listing tool there are none apparent.

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 front-loaded sentence that states the action, the data set, and the source standard with no wasted words. Every element 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?

This is a zero-parameter listing tool with no annotations but also no behavioral complexity. The output schema is present, so return values do not need to be described. The source standard and code list are explicitly named, making the description complete for an agent to select and invoke this tool.

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

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

The tool has zero parameters and the schema confirms this with an empty properties object, so according to the rubric the baseline is 4. There is no parameter meaning for the description to add.

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 ('List') and resource ('UNCL1153 reference qualifier codes'), and names the source standard ('CEF EN 16931 code list'). This clearly distinguishes it from sibling tools like check_reference_qualifier_code and other list_* codelist 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 'List' verb implies this tool is for enumerating all reference qualifier codes, and the sibling check_reference_qualifier_code implies the alternative for validation. However, this is only implied; the description does not explicitly state when to prefer this tool over checking a single 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?

With no annotations provided, the description carries the disclosure burden. It is transparent that this is a read-only listing operation ('List'), identifies the data source code list, and discloses the environment variable dependency. It does not spell out error behavior if the variable is missing, but for a simple read tool this is sufficient.

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 operational purpose is front-loaded, and the prerequisite is placed immediately after, making it easy for an agent 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?

The tool is low-complexity: one optional boolean parameter, no nested objects, and an output schema is present. The description covers what the tool lists, where the data comes from, and the required environment setup, so an agent has enough context to invoke it correctly.

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

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

Schema description coverage is 100%, and the single active_only parameter is already documented in the input schema with its default and meaning. The description adds no parameter-level detail, so it neither needs to compensate nor adds value 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 begins with a specific verb and resource: 'List Peppol SPIS use case identifiers from the OpenPeppol eDEC code list.' It names a distinct code-list domain (SPIS use cases) and source, separating it from sibling list tools such as list_process_ids, list_document_type_ids, and list_participant_id_schemes.

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

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

The description provides a clear prerequisite by stating EINVOICING_PEPPOL_CODELIST_DIR is required and points to list_participant_id_schemes for context. However, it does not explicitly state when to choose this tool over alternatives or when not to use it, so usage guidance is mostly implied by the purpose.

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?

No annotations are provided, so the description carries the behavioral disclosure burden. 'List ... from' clearly signals a read-only enumeration operation and identifies the exact source code list. The zero-parameter scope and presence of an output schema reduce the risk of unspecified behavior, though it does not explicitly discuss output ordering or response size.

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, information-dense sentence with no filler. The verb and resource are front-loaded, and every word contributes to the agent's understanding of what the tool returns.

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 parameterless list tool with an output schema, the description is complete enough to select and invoke correctly. The source code list is specified, and the output schema can carry the return structure, so no additional context is needed.

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 has zero properties and schema description coverage is 100%, so there are no parameters for the description to explain. With zero parameters, the baseline is 4, and the description correctly identifies the domain and source of the returned codes without needing to document 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?

The description names a specific verb (List), a precise resource (UNCL5305 VAT category codes), and the source (CEF EN 16931 code list). This clearly distinguishes it from the sibling check_vat_category_code, which checks a single code rather than enumerating 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?

The description implies the tool is for enumerating VAT category codes, but it does not explicitly state when to use it over check_vat_category_code or list_vatex_codes. Usage context is inferable from the name and wording, but no direct guidance or exclusions are given.

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 no annotations, the description carries the burden of behavioral disclosure. It clearly indicates a read-only listing operation with no side effects, but does not mention output format, sorting, pagination, or whether all codes are always returned. The behavior is simple enough that this is adequate but not richly transparent.

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

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

The description is a single, efficient sentence that states the action, resource, and source standard without unnecessary words. It is front-loaded and 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 a parameterless list tool with an output schema, the description is complete enough: it names the exact code list and the source standard. An agent can select and invoke this tool correctly without additional 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?

The tool has zero parameters, so there are no parameter semantics to explain. The empty schema plus 100% schema coverage means the description does not need to compensate for missing parameter 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 uses a specific verb ('List') and identifies a clear resource: VATEX (VAT exemption reason) codes from the CEF EN 16931 code list. This distinguishes it from siblings like check_vatex_code and list_vat_category_codes by stating exactly what is returned.

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 tool should be used when an agent needs the full list of VATEX codes, but it does not explicitly state when to choose this over the related check_vatex_code tool. No exclusions or alternative usage guidance is provided.

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?

No annotations are present, so the description carries the burden of disclosing behavior. It usefully reveals that the operation is public and unauthenticated, and clarifies it is unrelated to SMP lookup. However, it does not mention return behavior, pagination beyond schema defaults, or any operational caveats, leaving a moderate transparency 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?

The description is compact and front-loaded. The first sentence states the operation, and the second sentence conveys access mode, scope exclusion, and an invocation requirement. Every sentence earns its place without unnecessary elaboration.

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 a rich input schema and an output schema, the description provides the essential missing context: public access, unauthenticated use, non-relation to SMP lookup, and the required-filter condition. It could be slightly more complete by explicitly naming the SMP lookup sibling as the alternative, but it is otherwise sufficient.

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 already documents all 8 parameters with 100% coverage, so the baseline is 3. The description adds value by stating a cross-parameter constraint: at least one of q/participant/name/country/doctype must be supplied. This is information not otherwise encoded per-parameter in the schema.

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

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

The description opens with a concrete verb and resource: 'Search the Peppol Directory for registered participants.' It also distinguishes itself from sibling tools by stating it is 'no relation to SMP lookup', which prevents confusion with peppol_lookup_participant and related tools.

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

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

The description gives clear usage context: it is a public, unauthenticated search, and at least one of q/participant/name/country/doctype must be supplied. It also provides a when-not signal by disclaiming any relation to SMP lookup, though it does not explicitly name an alternative tool for SMP lookup.

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?

No annotations are provided, so the description must carry the behavioral burden. It discloses the two-step resolution process and a critical edge case: redirects set `redirect_url`, leave `endpoint_url` as None, and callers must not follow more than one hop. This is meaningful operational context beyond a simple fetch.

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 sentences with clear front-loading: purpose, process, and a notable redirect caveat. No filler or redundant restatement of 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?

The description plus output schema cover the main flow and the redirect edge case, and the warning about redirect hops is essential for correct use. It could additionally mention error handling or empty-result behavior, but nothing critical is missing for a lookup tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description only lightly reinforces that `document_type_id` selects the service metadata. It adds no new semantics for `identifier` or `environment` 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?

States a specific verb and resource: 'Fetch the AS4 endpoint for a Peppol participant's document type.' This clearly distinguishes it from siblings like resolve_peppol_dns or peppol_directory_search, which handle DNS resolution or directory searches.

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 tool is used when you need an AS4 endpoint for a Peppol participant, but it never names alternatives or gives exclusion criteria. It describes internal steps (DNS resolution, service metadata fetch) rather than when to prefer this tool over related lookup or send 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?

With no annotations provided, the description carries the transparency burden. It explicitly discloses a concrete multi-step network behavior: DNS-over-HTTPS U-NAPTR lookup followed by an SMP service-group request. The word 'check' also implies a read-only operation. It does not cover timeouts, failures, or rate limits, but the core behavioral profile is clear.

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

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

The description is two tight sentences with no wasted words. The core purpose is front-loaded, and the second sentence adds meaningful process detail without fluff.

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

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

Given that the parameters are fully documented and an output schema exists, the description is largely sufficient for correct invocation. It explains the underlying DNS/SMP behavior, but it does not address selection among overlapping sibling tools or potential failure/prerequisite conditions, so it is not fully complete.

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

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

Schema description coverage is 100%, and the schema already documents both identifier and environment in detail. The description adds no parameter-specific meaning, so the baseline score 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: 'Check whether a business is registered on the Peppol network.' It further defines the result as both registration status and supported document type identifiers, which clearly separates it from sibling tools like resolve_peppol_dns or peppol_get_service_endpoint.

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 use is implied by the purpose statement, but there is no explicit when-to-use or when-not-to-use guidance. Overlapping sibling tools such as resolve_peppol_dns, peppol_get_service_endpoint, and peppol_directory_search are not mentioned, so an agent gets no direct routing help.

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?

No annotations are provided, so the description carries the full burden. It discloses the main behavioral pipeline: SMP lookup of the AS4 endpoint, ebMS3/AS4 envelope construction, and transmission with signing credentials. This gives the agent a concrete model of what will happen when invoking the tool.

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

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

Two compact sentences with no filler. The primary action and delivery mechanism are front-loaded, and the second sentence adds necessary process detail 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 rich input schema, the presence of an output schema, and the straightforward send operation, the description is largely complete for selection and invocation. It could mention environment semantics or that the invoice should be validated first, but those are not critical to making a correct call and are partly captured by the schema.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters well. The description adds only light contextual framing like 'signing credentials' and 'UBL/CII invoice', which is useful but does not materially go 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?

States a specific verb and resource: 'Send a UBL/CII invoice to a Peppol participant via AS4.' It also distinguishes the tool from siblings like peppol_lookup_participant or invoice_validate by describing the actual transmission action rather than lookup, validation, or conversion.

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: this is the tool to use when you need to transmit an invoice to a Peppol participant. It does not explicitly name alternatives or exclusions, but the scenario is unambiguous and the sibling names make the distinction apparent.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly states that the tool performs a raw U-NAPTR DNS lookup and does not fetch the SMP service group, setting accurate expectations about scope and side effects. It does not discuss failure modes or network behavior, but the core behavioral boundary is well disclosed.

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 only two sentences, with the primary action front-loaded and the second sentence adding a precise technical boundary and use case. Every sentence earns its place, and there is no redundant filler.

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

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

Given the simple parameter set, an output schema, and no nested objects, the description is complete enough for an agent to select and invoke the tool correctly. It explains what the tool does, what it deliberately avoids doing, and the diagnostic scenario where it is useful.

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 input schema already documents both parameters well. The description adds high-level context about Peppol and DNS but does not add meaning beyond what the schema provides for identifier or environment.

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 and resource: 'Resolve the SMP hostname for a Peppol participant via DNS only.' It also distinguishes itself from similar tools by explicitly saying it does a raw U-NAPTR lookup without fetching the SMP service group, so an agent can tell it apart from fuller Peppol 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?

The description gives a clear use context: diagnosing whether a participant is registered in the SML independently of SMP reachability. It implies a focused, low-level DNS-only check, but it does not explicitly name sibling alternatives or state when not to use them.

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?

No annotations are provided, so the description carries the full burden. It clearly signals a read-only lookup by starting with 'Query' and saying it 'Returns structured information.' It does not discuss rate limits or permissions, but that is acceptable for a simple query tool.

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

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

The description is front-loaded with the core action, followed by a dense but relevant enumeration of covered VAT topics, and closes with concrete use cases. Every sentence earns its place, and there is no filler or repetition of schema 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?

With an output schema present and both parameters fully documented, the description covers the domain, content, and primary use case well. The only meaningful gap is that it does not route agents away from this tool toward the many sibling code-list tools when a simple code-list lookup is required.

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 does not add meaning beyond the schema for the 'query' and 'context' parameters, though its list of VAT topics hints at valid query intents. It does not explain how context filters the returned rules.

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 ('Query') and resource ('German VAT rules for e-invoicing'), and enumerates the exact rule categories and statutes covered. It is clear, but it does not explicitly differentiate itself from sibling code-list tools like list_vat_category_codes or check_vatex_code, which overlap on VAT category and VATEX code topics.

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 context for when to use the tool: 'For use when building invoice creation logic or validating VAT treatment.' However, it does not mention alternatives or exclusion criteria, particularly when an agent should prefer the sibling list/check code-list tools instead.

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 no annotations provided, the description carries the full disclosure burden. It usefully reveals the two-stage validation behavior (XSD structural validation followed by Schematron business rules) and flags the optional [xslt2] dependency. It does not mention side effects, but validation is reasonably understood as non-mutating.

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 short sentences, front-loads the core purpose, and every phrase adds value. The note about the optional extra is relevant and concise.

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-parameter validation tool with an output schema present, the description covers the input nature, the validation process, and a key dependency. It is slightly limited by not clarifying when to prefer this over sibling validators, but otherwise the agent has enough to invoke it correctly.

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

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

The single parameter has full schema description coverage, so the schema already documents that it takes a base64-encoded EUSR XML document. The description adds process-level context but no additional parameter-level details, so the baseline of 3 applies.

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

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

The description clearly states the verb ('Validate') and the specific resource: a Peppol End User Statistics Report (EUSR) document. It does not explicitly distinguish itself from sibling tools like validate_tsr_report or validate_mls_message, but the document-type specification makes its purpose 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?

The description implies usage: it is the tool to call when you have an EUSR document to validate. However, it provides no explicit when-to-use guidance or exclusions, and it does not mention the closely related sibling validators that handle other report formats.

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 no annotations, the description carries the behavioral burden and it does so by disclosing the validation mechanism (Schematron), the dependency ('requires the xslt2 optional extra'), and the boundary (no bespoke MLS XSD, no full UBL XSD validation). It does not describe the result structure, but an output schema is present, so that gap is covered 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 description is front-loaded with the core purpose and adds only two high-signal caveats: the Schematron/XSLT dependency and the XSD scope boundary. 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?

For a single-parameter validation tool with a complete input schema and output schema, the description covers the method, dependency, and scope boundary. It is complete enough to invoke correctly, though it could optionally name related build/validate siblings for routing.

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 mls_xml_base64 as Base64-encoded MLS (UBL ApplicationResponse-2) XML. The description adds context about Schematron validation but does not explain parameter syntax or encoding beyond what the schema states; baseline 3 is appropriate.

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

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

The description opens with 'Validate a Peppol Message Level Status (MLS) document,' stating a specific verb, resource, and document type. It distinguishes this from sibling validators like validate_tsr_report and validate_eusr_report by the MLS scope, though it does not name a sibling explicitly.

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 clearly frames the tool as the MLS validation path ('Runs the bundled MLS Schematron rules') and gives an explicit exclusion: 'No bespoke MLS XSD exists — full UBL 2.1 XSD validation is out of scope.' It does not name alternative tools or spell out when-not in comparison to siblings, but the document-type condition 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 no annotations, the description carries the burden of behavioral disclosure. It goes beyond a generic 'validates' by stating that XSD structural validation runs first, followed by Schematron business-rule checks, and it warns that the Schematron step requires the [xslt2] optional extra. This gives an agent useful operational expectations, though side-effect/error behavior is not detailed.

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 filler: the first states the tool's purpose, the second explains the validation process and dependency. Information is front-loaded and 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 one-parameter validation tool with an output schema present, the description covers the key operational context: document type, validation steps, and a required extra. It does not explicitly state what happens if the xslt2 extra is missing or describe return semantics, but the output schema likely covers result shape, so no major gap remains.

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

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

The input schema already documents the sole parameter as 'Base64-encoded TSR XML document,' giving 100% schema coverage. The description does not add any parameter-specific detail beyond confirming the document type, so the baseline of 3 applies.

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

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

The description opens with a specific verb and object: 'Validate a Peppol Transaction Statistics Report (TSR) document.' It then details the two validation stages (XSD, then Schematron), which clearly separates it from sibling validation tools like validate_eusr_report or invoice_validate.

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 specifies a clear use case: validation of TSR documents, and explains the validation pipeline. It does not explicitly name sibling alternatives or give a when-not-to-use condition, but the resource-specific wording ('TSR') makes the intended scenario unambiguous.

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