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 does state that the result is base64-encoded, which is an important characteristic. However, it does not mention validation behavior, error handling, or whether the operation has any side effects, leaving some important traits unspecified for a tool with zero annotation hints.

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 action and output format are front-loaded, and the alternative is given in the second sentence. 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?

The description explains the tool's purpose, output encoding, and the key distinction from per-line building, while the output schema covers return details and the input schema covers parameters. It does not elaborate on the 'document-level' concept further, but for a builder with complete schemas, the provided context is largely 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%, so every parameter is already documented in the input schema. The description does not add additional parameter-level meaning, which is acceptable and matches the baseline of 3.

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

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

The description uses a specific verb ('Build') with a clearly defined resource ('document-level MLS response') and specifies the return format ('base64-encoded'). It also distinguishes this tool from per-line response building, removing ambiguity about its scope.

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 second sentence explicitly tells the agent when *not* to use this tool: for per-line responses, it should build the document directly with `mcp_einvoicing_core.peppol.mls.build_mls`. This is clear, actionable, and directly addresses the key alternative.

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 disclosing behavior. It does convey the core behavior: the tool tests whether a supplied code is a recognized allowance reason code. It does not disclose details such as case sensitivity, error behavior, or what 'recognized' means across codelist versions, but these are secondary for a simple predicate.

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. Every word matters, and it is appropriately sized for a one-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 check tool with an output schema, the return value is covered elsewhere. The description is minimally viable, but it omits guidance on how to obtain valid codes and any nuances of what 'recognized' means, leaving some gap that an agent would need to resolve via sibling tools.

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 string named 'code' with no description or enum, and schema description coverage is 0%. The description adds that the parameter should be an allowance reason code and that it is tested for recognition—this is meaningful semantic context beyond the raw schema, though it stops short of giving formats, examples, or valid value sources.

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 ('allowance reason code'), and 'recognized' makes clear this is a membership test against a codelist. It is distinguishable from sibling list_allowance_reason_codes and other check_* tools because it names its exact codelist domain.

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

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

The use case is implied by 'Check whether'—an agent can infer it should be used when a single allowance reason code needs validation. However, it never explicitly mentions the alternative list_allowance_reason_codes or states when not to use this tool, so guidance is only 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?

No annotations exist, so the description carries the full burden. 'Check whether' signals a read-only validation predicate, and 'recognized' indicates membership against a canonical codelist, but behavior on unknown values, case sensitivity, and error conditions are not disclosed. This is adequate for a simple check tool, but not much more.

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 short sentence with no filler; every word contributes meaning. However, the extreme brevity also leaves behavioral details underspecified, so it earns high but not top marks for structure.

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

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

For a one-parameter read-only check with an output schema, the core action is clear. The main gap is that the description does not indicate where valid charge reason codes come from or mention list_charge_reason_codes as the way to discover them, leaving some ambiguity around 'recognized.'

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 identifies *code* as the value being checked, but gives no format, length, case, or accepted source; this role is nearly identical to the property name and tool name, so the added meaning is minimal.

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 action ('Check whether') and a specific resource ('recognized charge reason code'), making the tool's predicate behavior unmistakable. It also differentiates from the sibling list_charge_reason_codes by implying membership testing 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?

There is no when-to-use guidance, no mention of alternatives, and no exclusion criteria. With many list/check sibling tools, the agent is left to infer that this tool validates a single code and that list_charge_reason_codes would be used to enumerate valid values.

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 frames the operation as a non-mutating validation predicate against a recognized standard, which meaningfully conveys behavior. It does not discuss edge cases like case sensitivity or invalid input handling, but those are minor for a one-parameter checker and the output schema 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?

A single, front-loaded sentence with no wasted words. It names the verb, the parameter, and the validation standard all in one concise line.

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

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

The tool is simple: one required parameter, an output schema is available, and no annotations exist. The description provides enough for an agent to select and call the tool correctly. The only gap is the lack of explicit routing guidance among the many sibling list/check tools.

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%, but the descriptionr̃ name in context and adds real semantics: it must be an ISO 3166-1 alpha-2 country code. This goes beyond the schema's bare `string` type by specifying both the standard and the code form.

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'), a specific resource (ISO 3166-1 alpha-2 country code), and the exact input format. It clearly distinguishes this tool from siblings like list_country_codes and check_currency_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 intended use is implied: call this when you need to know if a given code is a recognized country code. However, the description does not explicitly say when to prefer this over list_country_codes or other check_* tools, nor does it mention any exclusion 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?

There are no annotations, so the description carries the full behavioral disclosure burden. It does convey a read-only validation check and implicitly promises a yes/no style result, but it remains silent on potentially important traits such as case sensitivity, behavior on malformed input, and whether unrecognized codes produce false or an error. For a simple predicate this is adequate but with clear gaps.

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

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

The description is one focused sentence that leads with the core operation and uses a clear placeholder for the parameter. Every word contributes to understanding, with no redundant filler or repetition 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?

Given the tool's simplicity, one parameter, and presence of an output schema, the description covers the essential purpose and parameter meaning. It does leave usage routing vs list_currency_codes implicit and omits input-format edge cases, but these are minor for a check tool and no critical context is missing.

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

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

The input schema provides only a string named 'code' with no description, so the schema coverage is 0%. The description compensates by defining code as an ISO 4217 currency code, adding real meaning beyond the raw type. It does not provide format examples or normalization details, but for a single parameter this level of semantic guidance is strong.

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') on a specific resource ('ISO 4217 currency code'), and the use of 'whether' makes its validation purpose unambiguous. It is easily distinguished from sibling list_currency_codes, which would enumerate all codes rather than test 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 intended use is implied: call this tool when you have a code and need to verify that it is a recognized ISO 4217 currency code. However, the description never explicitly contrasts it with list_currency_codes or says when to prefer one over the other, leaving alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a non-mutating membership check, but does not state how unrecognized codes are represented in the output, whether matching is exact/case-sensitive, or whether any normalization occurs. For a read-only check tool this is acceptable but minimal.

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, directly front-loaded with the action and target, with no filler or redundancy. Every word contributes useful information.

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

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

For a one-parameter, read-only membership test with an output schema available, the description provides essential selection and invocation context. It does not elaborate on output or error semantics, but the output schema can carry that information; the only minor gap is implicit usage guidance.

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

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

The schema only provides a bare string type with 0% description coverage. The description compensates by defining the parameter as an UNCL1001 document name code to test, adding domain meaning beyond the schema. It stops short of providing format examples, but for a single scalar code parameter this 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 states a specific verb ('Check whether') applied to a precisely named resource ('UNCL1001 document name code'). This clearly distinguishes it from sibling tools that list codes or check different 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 verb 'Check whether' implies a single-code membership test, and the sibling set suggests list_* tools are for enumeration. However, the description does not explicitly state when to use this tool versus list_document_name_codes or other check_* tools, leaving usage guidance 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 full burden of behavioral disclosure. It adds useful context: the search includes deprecated/removed entries and requires a dedicated environment variable. However, it does not disclose the return shape (e.g., boolean), error behavior, or performance characteristics, so transparency is partial.

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 the first clause, followed by a prerequisite and a behavioral nuance. Every sentence earns its place, and the structure is conventionally 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-parameter existence check, the description covers the essential semantics, an environmental prerequisite, and a non-obvious behavioral detail. Yet because there is no output schema and no annotation, the description still omits the exact return format and error conditions, which are the kind of details an agent would need 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%, and the description only refers to the pair as '(scheme, value)' without explaining each parameter's format, allowed values, or relationship. An agent can infer that scheme is the identifier scheme and value is an ID, but the description does not compensate for the absence of any property descriptions 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 states a specific verb ('check') and a clear resource ('Peppol document type identifier') against a codelist, which immediately distinguishes it from sibling check_* tools such as check_process_id_in_codelist and check_document_name_code. The subject-verb-object structure is unambiguous and front-loaded.

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 a cross-reference to list_participant_id_schemes, but it never says when to use this tool versus the many adjacent check_* and list_* tools. No when-not or alternative guidance is provided, leaving tool selection to inference from the name.

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 disclosure burden. 'Check whether' conveys that this is a read-only validation operation, but the description does not disclose edge-case behavior such as case sensitivity, handling of unrecognized codes, or whether it returns a simple boolean.

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 sentence with no filler. It front-loads the core action and resource immediately, making it easy for an agent 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?

Given the tool's low complexity, single parameter, and presence of an output schema, the description is largely sufficient for an agent to understand the call. It could additionally reference list_eas_codes as the source of valid values, but this is a minor gap rather than a completeness failure.

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 0% description coverage, so the description must compensate. It does clarify that *code* is the EAS code being checked, adding semantic meaning beyond the raw schema. However, it does not provide format details, examples, or whether the code should be taken from list_eas_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 ('Check whether') and resource ('recognized Electronic Address Scheme code'), making the tool's function immediately clear. It also distinguishes this tool from the many sibling check_*_code tools by naming the EAS codelist 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?

The description implies the tool should be used when the agent has a specific code and needs to verify membership in the EAS codelist. However, it does not explicitly mention the alternative list_eas_codes for enumerating valid codes, 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool checks recognition against ISO 6523, but it does not describe whether the result is a boolean, how malformed or unrecognized codes are handled, case sensitivity, or any error behavior.

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

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

A single sentence with no filler or repetition. The core idea is front-loaded and the resource type is made explicit. It is concise without being empty, though the terseness contributes to missing behavioral 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?

Given the tool's simplicity, one parameter, and presence of an output schema, the description is adequate for the basic happy path. However, the lack of usage guidance and edge-case behavior, combined with zero annotations, leaves a noticeable gap for an agent selecting among many similar siblings.

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

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

The input schema only defines code as a string with no description, while schema description coverage is 0%. The description adds meaningful semantics by clarifying that the code must be an ISO 6523 ICD code, but it stops short of supplying format examples, regex hints, enumerations, or length 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 states a concrete action, 'Check whether', applied to a specific resource: a recognized ISO 6523 ICD code. This clearly distinguishes it from list_icd_codes, which would enumerate codes, while not being as sharp as it could be about the exact return contract.

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 provided about when to use this tool rather than list_icd_codes or another check_*_code sibling. The intended use can be inferred from the name and siblings, but the description does not state 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 carries the full burden of explaining behavior. It states the check occurs but does not disclose the return format, whether a boolean or detailed result is produced, case sensitivity, matching rules, or any side effects. 'Check whether' implies a read-only predicate, but that is not 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 a single sentence with no redundant words. It is appropriately concise for a simple validation tool and 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?

The tool has low complexity (one required string parameter) and an output schema, so the description need not explain return values in detail. However, it lacks any usage context versus sibling list/check tools and omits behavioral nuances like what 'recognized' means or how a negative result is expressed. It is minimally adequate but far from 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 provides 'code' as a string with no description, and schema coverage is 0%. The description adds that the parameter is an 'item type identification code,' giving it a semantic category. However, this is not much more than the tool name, and it does not offer format, examples, or allowed values, so it only partially compensates for the missing schema documentation.

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

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

The description uses a specific verb ('check whether') and identifies a distinct resource ('item type identification code'), so an agent can tell this is a validation tool for that code type. It is clear, though it does not explicitly contrast it with the sibling list_item_type_codes tool, so it stops short of full sibling differentiation.

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

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

No guidance is given about when to use this tool instead of alternatives such as list_item_type_codes or other check_* tools. The intended usage is only implied by the word 'check' and the resource name, with no explicit conditions 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 provided, so the description carries the burden of behavioral disclosure. 'Check whether' signals a non-mutating validation operation, but the description does not explicitly state behavior for unrecognized codes, whether it is a pure predicate, or any access limitations. It does not contradict annotations, but it adds only minimal behavioral 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?

The description is a single sentence with no filler. The action ('Check'), subject ('code'), and qualification ('recognized MIME type for embedded attachments') are all front-loaded and directly useful.

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 covers the core purpose and parameter meaning completely enough to call the tool. It is slightly incomplete only in that it does not point to list_mime_codes for enumeration or describe how unrecognized codes are handled, but these are minor gaps for such a simple 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?

With schema description coverage at 0%, the description is the only source of parameter meaning. It clearly identifies the single parameter as a MIME type used for embedded attachments, going well beyond the generic string type in the schema. It does not provide examples or an explicit format, but for a single simple parameter this 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 uses a specific verb ('Check') and a specific resource ('recognized MIME type for embedded attachments'), making the tool's operation unambiguous. It also distinguishes this from sibling tools that list code sets or validate other kinds of codes, such as check_payment_means_code or check_vat_category_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 clearly implies the tool is for validating a single MIME code, but it does not explicitly say when to use this tool versus list_mime_codes or other check_*_code siblings. The intended usage is inferable from the name and wording, but no direct guidance or exclusions 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It does reveal an important prerequisite (EINVOICING_PEPPOL_CODELIST_DIR) and implies a read-only boolean check, but it doesn't describe error behavior, return format, or side effects. The presence of an output schema reduces the need to document return values, but the description alone is still fairly thin.

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 core action and input format are front-loaded, and the prerequisite/environment-variable note is placed separately and clearly.

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 predicate with an output schema, the description covers the input format and the key prerequisite. The reference to `list_participant_id_schemes` is slightly vague but still provides a path for an agent to discover more context. It is adequate but not exhaustive.

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 says `icd` is a string, but the description adds that it must be a 4-digit ISO 6523 ICD code with the example `0208`. This compensates for the 0% schema description coverage and gives enough format information for an agent to construct a valid argument.

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 and resource: checking whether a 4-digit ISO 6523 ICD code is a recognized Peppol scheme. This is clear and more specific than generic ICD checks like `check_icd_code`, though it doesn't explicitly name an alternative to distinguish itself from siblings.

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

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

The intended use is clear: validate a participant identifier scheme code against the Peppol codelist. It adds a prerequisite (environment variable) and points to the companion `list_participant_id_schemes` tool, giving an agent useful context for when to invoke this tool, though it doesn't explicitly 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool checks membership in a specified codelist, which is appropriate for a simple read-only check. However, it does not state whether an unrecognized code returns false or raises an error, nor any normalization or case-sensitivity behavior.

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

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

The description is a single, front-loaded sentence with no filler. It states the action and the resource immediately, and every word contributes to understanding the tool's purpose.

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 simple one-parameter codelist membership check, and an output schema exists, so the return shape does not need to be explained in the description. The codelist and input are clearly identified, which is enough for an agent to invoke the tool correctly; minor gaps around invalid input behavior and alternative tools are not fatal.

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 for the schema's bare 'code' string parameter. It does add essential semantics by identifying the value as a UNCL4461 payment means code, but offers no format details, examples, or additional constraints. This meets the minimum bar but nothing more.

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 ('UNCL4461 payment means code'). It clearly distinguishes the tool from list_payment_means_codes and other codelist checkers by naming the exact codelist it validates against.

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 this tool is for validating a single payment means code against UNCL4461, while siblings like list_payment_means_codes are for enumeration. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full 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 must carry behavioral disclosure. It usefully discloses an environment prerequisite, but does not state whether the check is read-only, what its return behavior looks like, or how failures are signaled. The output schema may cover return values, but the description itself is thin on side effects and error behavior.

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

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

Two sentences with no filler; the purpose is front-loaded and the prerequisite is the only additional information. 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 is simple (two string params, output schema exists), so this description is mostly adequate for selecting and invoking it. However, given the directory requirement, the agent would benefit from a pointer to where process identifiers can be listed (e.g., list_process_ids) to fill valid values.

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 for the parameter definitions. It only says that scheme and value form a pair to be checked, adding little beyond their names; it never defines valid schemes/values or references list_process_ids for valid process identifiers.

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 specific resource: a (scheme, value) pair as a Peppol process identifier. This clearly distinguishes it from the list_* siblings, though it does not explicitly call out check_participant_id_scheme_in_codelist as its closest sibling.

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

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

The only usage guidance is the prerequisite EINVOICING_PEPPol_CODELIST_DIr and a pointer to list_participant_id_schemes for that context. It does not say when to prefer this over other check_* tools or list_process_ids, nor what to do when the pair is not recognized.

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 accurately states the core behavior (checking recognition of a code) but does not add details such as whether the check is case-sensitive, how empty or malformed codes are handled, or whether the result is a simple boolean. It is not misleading, just minimal.

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, front-loaded sentence with no filler. It states the operation, the target resource, and the key parameter in one compact statement. Nothing is over-explained or redundant.

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 a simple single-parameter checker, and the output schema is provided, so return value details are already covered. The description plus sibling context gives enough information for correct invocation. A minor gap is the lack of any mention of the codelist source or examples, but the simplicity lowers that need.

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 does clarify that 'code' refers to a UNCL1153 reference qualifier code, giving the parameter meaning beyond the bare type 'string'. However, it does not specify format, length, or accepted examples, leaving some ambiguity for the agent.

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 a specific resource ('UNCL1153 reference qualifier code'), making it clear this tool validates a single code. It naturally distinguishes itself from sibling list_reference_qualifier_codes and the other check_* tools by naming the exact 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 description implies usage: when you have a code and want to verify it against UNCL1153. It does not explicitly state when not to use it or mention the sibling list_reference_qualifier_codes, but the contrast with the sibling is fairly evident from naming conventions.

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 exist, so the description carries the full burden. It discloses that the tool performs recognition/validation against UNCL5305, but it does not describe behavior for unknown codes, malformed input, case sensitivity, or what it returns beyond the output schema. For a simple read-only check this is adequate but not rich.

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

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

One short sentence, front-loaded with the verb and resource. Every word earns its place; there is no filler.

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

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

The tool is a simple one-parameter validation check and an output schema exists, so return-value details are not needed in the description. The main gap is explicit usage guidance relative to list_vat_category_codes, but the low complexity and clear purpose keep the definition reasonably 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 input schema only says 'code' is a string, and schema description coverage is 0%. The description adds that the code must be a recognized UNCL5305 VAT category code, which gives essential semantics, but it does not give examples, format details, or allowed values.

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: a UNCL5305 VAT category code. This clearly distinguishes it from sibling check_* tools that validate other codelists, while its relationship to list_vat_category_codes is implied.

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 word 'Check' implies single-code validation versus listing all codes, but there is no explicit statement about when to use this tool instead of list_vat_category_codes or other check_* tools. The usage context is inferable from the description and sibling names, not stated.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It makes clear the operation is a membership/recognition test and implies no side effects, but it does not disclose case sensitivity, behavior for unknown or empty codes, or whether the lookup is local or remote.

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, front-loaded with the verb and subject, with no filler. Every word contributes to understanding the tool's 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?

For a single-parameter validation tool with an output schema, the description is nearly complete. It lacks only an explicit pointer to list_vatex_codes for enumerating valid codes and a note on edge-case behavior, but neither is necessary to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does add domain meaning by identifying the sole parameter as a VATEX VAT exemption reason code candidate, but it does not specify format, length, or where valid values come from beyond the code list context.

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

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

The description states a specific verb ('Check') and a precise resource ('VATEX VAT exemption reason code'), so the tool's purpose is immediately clear. It also distinguishes itself from the sibling list_vatex_codes and other check_*_code tools by naming the exact code domain.

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 list_vatex_codes or the other check_*_code tools. The check/list sibling pattern implies a use case, but it is left entirely 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?

No annotations are provided, so the description carries the full burden. It discloses the output structure and the fact that it applies customizationID and profileID, but does not mention authentication needs, side effects, or prerequisites.

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 paragraphs with no filler. The first sentence states the purpose, followed by profile handling, then return values. Every sentence adds value.

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

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

The description explains what it does, the output format, and the profile application. It could mention error handling or validation of invoice_data, but given the existence of an output schema, it is fairly 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 100%, so the description adds no additional meaning beyond what the schema already provides. The description does not elaborate on the parameters (e.g., invoice_data structure).

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 generates a UBL 2.1 Belgian e-invoice XML from structured data, specifying the output is ready for Peppol or Mercurius. It distinguishes well from siblings (parsing, validation, checking) by focusing on generation.

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 or when not to use it. Usage is implied by the clear purpose, but no explicit 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 provided, so the description carries the full burden. It uses the non-mutating verb 'Report' and explicitly scopes the data source to 'currently configured locally,' indicating a local read rather than a remote lookup. This is meaningful behavioral context, though it does not discuss return formatting or permissions.

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

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

The description is a single, directly worded sentence with no filler. It front-loads the action and target and 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 zero-parameter read-only version query, the description adequately covers the target ('CEF EN 16931'), the source ('locally configured'), and the currentness ('currently'). An output schema is present, so return-value details are not required 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 an empty input schema with 100% coverage, so there are no parameter semantics the description needs to add. The baseline for zero-parameter tools is 4.

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

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

The description states a specific verb ('Report') and a specific resource ('CEF EN 16931 code-list release version(s)'), and scopes it to currently configured local state. This clearly distinguishes it from the sibling get_peppol_codelist_version and the many list/check 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 phrase 'currently configured locally' implies when this tool is useful, but the description does not explicitly explain when to prefer it over get_peppol_codelist_version or provide when-not-to-use conditions. 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?

No annotations provided, so description must convey behavior. It clearly states it returns data (read-only) with no side effects. While it could explicitly state it's idempotent and safe, the description is sufficiently transparent for a simple query.

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 purpose. Every word is informative. No redundancy or 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 no paramaters and an output schema (assumed present), the description covers the key return information. It could hint at static nature or usage pattern, but it's largely complete for a reference data 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?

No parameters (baseline 4). The description explains what the return data contains (invoice types and UBL values), adding meaning beyond the empty schema. No param documentation needed.

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 it returns supported Belgian e-invoice document types, lists the specific types with codes (380, 381, 383), and mentions UBL identifiers. This distinguishes it from sibling tools like generate_invoice_be or validate_invoice_be, 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?

No explicit guidance on when to use or when not, but the purpose is simple and self-evident. With siblings covering generation, validation, and transformation, the agent can infer this is for reference. However, explicit context would improve the score.

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 clearly signals a read-only reporting action ('Report') and discloses that the value is based on local configuration rather than a remote source. It does not detail return shape, but the output schema can cover that.

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

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

The description is a single sentence with no filler, and the key subject ('OpenPeppol eDEC code list release version(s)') is 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?

For a zero-parameter, local read-only status check, the description is nearly complete. It correctly frames what is being reported and where the data comes from, and the output schema can document the exact return structure. The only minor gap is not explicitly contrasting it with the EN16931 codelist version sibling.

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 accepts zero parameters, so the schema is fully self-describing and there are no parameter semantics to explain. The baseline of 4 for zero-parameter tools applies, and the description adds no contradictory 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?

Description states a clear verb ('Report'), a specific resource ('OpenPeppol eDEC code list release version(s)'), and the local scope ('currently configured locally'). It is easy to distinguish from the sibling get_en16931_codelist_version because the description explicitly names the eDEC 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 intended use case—checking the locally configured eDEC code list version—is clear from the description and the tool name. It does not explicitly offer when-not-to-use guidance or point to the similar EN16931 tool, but the OpenPeppol eDEC mention gives enough context to select it appropriately.

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 nnotations are providedso the description carries the behavioral burden . 'List' from a code list implies a non - damaging lookup and the output schema covers the return shape , but no further details such as authorization , ordering , or pagination are stated . This is minimal yet adequate for a simple listing 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?

A single sentence that states the action , resource , and source standard with no redundancy . It is front - loadedand 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?

Given the low complexity , zero parameters , and presence of an output schema , the description is essentially complete for selecting and invoking the tool . A brief reference to the sibling check tool would be a nice improvement but is not necessary for correctness .

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 an empty schema , so there is nothing for the description to explain about inputs . The baseline for 0 parameters is 4 , and no param info is needed .

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 ('allowance reason codes') and nameshte source standard (CEF EN 16931) . This distinguishes it from sibling tools like check_allowance_reason_code and list_charge_reason_codes without requiring schema inspection .

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

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

The commit implies usage: call this tool to enumerate allellowance Reason codes from the code list . However , it does not explicitly contrast with check_allowance_reason_code or other list tools , so thewhen-to -use vs alternatives 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. The verb 'List' clearly signals a read-only enumeration with no mutation, and the standard code-list source is identified. It does not disclose details like caching or whether deprecated codes are included, but for a zero-param list operation this is reasonably 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, front-loaded sentence with no filler. Every word adds meaning: List, charge reason codes, and the CEF EN 16931 code 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 zero-parameter list tool with an output schema present, this description is complete. The agent knows what data is returned and the source; no parameter or return-value explanation is necessary.

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 schema already provides complete coverage. The description adds no parameter information, which is acceptable; the baseline for zero parameters is 4.

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

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

The description uses a specific verb ('List') with a clear resource ('charge reason codes') and identifies the source ('CEF EN 16931 code list'). This distinguishes it from siblings such as check_charge_reason_code and list_allowance_reason_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 by the verb 'List' and the sibling naming patterns: list versus check. However, the description does not explicitly tell the agent when to choose this tool over check_charge_reason_code or other list 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly indicates a read-only enumeration and specifies the source list (CEF EN 16931), which is sufficient for this simple no-parameter tool. It does not overstate side effects or hide mutation behavior.

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

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

The description is one concise sentence that front-loads the action and the exact resource. Every word adds specification, with no filler or repetition.

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

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

For a zero-parameter list tool with an output schema, the description is complete: it names the exact code standard (ISO 3166-1 alpha-2) and the source list (CEF EN 16931). No prerequisites, permissions, or side effects need disclosure for this straightforward read-only 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 tool has zero parameters and the schema description coverage is 100%, so baseline 4 applies. The description adds no parameter semantics because there are no parameters requiring 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 resource ('ISO 3166-1 alpha-2 country codes from the CEF EN 16931 code list'), making it clear what the tool returns. This distinguishes it from sibling tools like list_currency_codes, list_payment_means_codes, and check_country_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 usage: call it when you need the list of allowed country codes. However, it does not explicitly say when to prefer it over the sibling check_country_code or other list_* tools, nor does it describe exclusions or alternatives.

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

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

With no annotations, the description carries the burden, and it states the tool lists codes, clearly indicating a read-only enumeration. It names the source code list, but does not explicitly describe output shape; however, the output schema exists.

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

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

A single, front-loaded sentence with no unnecessary words. It efficiently conveys the verb, resource, and source.

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 complete enough: the agent knows what to invoke and what domain the codes come from.

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

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

The tool takes zero parameters, so the description has no parameter semantics to add. The baseline of 4 applies since no parameters are present.

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

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

The description names the specific verb 'List' and resource 'ISO 4217 currency codes' from the 'CEF EN 16931 code list'. It is clearly distinguished from siblings 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 clearly implies use when an agent needs a list of all ISO 4217 currency codes rather than checking a single code. It does not explicitly mention alternatives, but 'List' versus 'check' is apparent from the sibling tools.

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

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

With no annotations, the description carries the behavioral burden. 'List' clearly indicates a read-only enumeration, and naming the exact code list provides context. It does not mention edge cases such as empty lists or versioning, but for a zero-parameter listing tool this is minor, especially with an output schema available.

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 front-loaded sentence with no filler. The verb, object, and source are all present, and every word contributes to understanding the tool's purpose.

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, the description plus output schema is nearly complete. It identifies the exact code list and resource. A short pointer to the sibling check_document_name_code tool for validating a single code would have made usage guidance more complete, but the invocation itself is fully 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?

The tool has 0 parameters and the schema already documents this fully, so the baseline is 4. The description adds no parameter-level information, but none is needed.

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 specific resource ('UNCL1001 document name codes'), and a specific source ('CEF EN 16931 code list'). This distinguishes it clearly from its sibling check_document_name_code and 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 makes clear what the tool returns, so usage is implied: call it when you need the available document name codes. However, it does not explicitly state when to prefer this over check_document_name_code or other list tools, leaving that decision 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?

No annotations are provided, so the description must carry behavioral context. It discloses an important environment requirement, which is useful. However, it does not explicitly state that this is a read-only listing operation or describe any other behavioral traits such as error conditions or performance characteristics.

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 concise sentences with no filler. The main purpose is front-loaded, and the prerequisite is clearly separated in the second sentence. Every sentence contributes useful information.

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

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

Given the tool's low complexity, a single optional parameter, an existing output schema, and the environment prerequisite being mentioned, the description is mostly complete. The only notable gap is lack of explicit guidance on when to use this tool versus a sibling like check_document_type_id_in_codelist.

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

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

The schema already fully describes the only parameter (`active_only`) with a clear default and meaning. The description adds no additional semantic value for parameters, 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 uses a specific verb ('List') and a clear resource ('Peppol document type identifiers from the OpenPeppol eDEC code list'). It is distinguishable from many sibling codelist tools, though it does not explicitly contrast with similar tools like list_document_name_codes or check_document_type_id_in_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 intended use is implied by the name and description, but there is no explicit when-to-use guidance or mention of alternatives. The prerequisite note about EINVOICING_PEPPOL_CODELIST_DIR provides useful context and points to a sibling for setup, but it does not explain when to choose this tool over another.

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 states the operation and source, but does not specify whether the returned list is exhaustive, whether any limitations exist, or any further behavioral details. There is no contradiction with the structured data.

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 expands the abbreviation and names the exact source while remaining 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 zero-parameter list operation with an output schema present, the description is sufficiently complete. It tells the agent what the tool lists and from which source; return-value details are covered by the output schema.

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

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

There are zero input parameters and the schema has 100% coverage, so no parameter descriptions are needed. The description does not add parameter information, but the schema already fully documents that 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 uses a specific verb ('List') and resource ('Electronic Address Scheme codes') and names the authoritative source ('CEF EN 16931 code list'). This clearly distinguishes it from sibling check_eas_code, which is for checking 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 word 'List' implies this is for enumerating all EAS codes, and the named sibling check_eas_code suggests the alternative, but the description does not explicitly state when to use this tool versus checking a code. Usage guidance is only implicit, not explicit.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. 'List' conveys a read-only operation and the source is clearly stated, but no detail is given about return behavior, ordering, filtering, or potential limitations.

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 redundant or filler content. It states the action, the object, and the source 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 parameterless listing tool with an output schema, the description provides enough context: the resource type and exact code list source. No additional invocation details are 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 tool has zero parameters and the schema confirms this with full coverage. The description does not need to explain parameters, so the baseline of 4 applies.

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

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

The description names a specific verb ('List'), a specific resource ('ISO 6523 ICD codes'), and the source list ('CEF EN 16931 code list'). It is clearly distinguishable from sibling tools such as check_icd_code and 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 provides no guidance on when to use this tool instead of related alternatives like check_icd_code for validating a single ICD code. Usage context must be inferred entirely from the tool name and sibling list.

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 describes a read-only listing operation from a specific codelist, but it does not mention details such as completeness, ordering, or versioning behavior. The zero-parameter schema and output schema reduce the need for deeper 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 a single, front-loaded sentence with no filler. Every word contributes to identifying the tool's purpose and source.

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 available, the description is nearly complete. It could be slightly stronger by explicitly referencing the check_item_type_code sibling for single-code verification, but the low complexity makes that 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 input schema is empty with no parameters, so there is nothing for the description to document. Schema coverage is 100%, and the description still adds useful source context by naming the CEF EN 16931 code list.

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 concrete action ('List'), a specific resource ('item type identification codes'), and a source list ('CEF EN 16931 code list'). It is immediately distinct from sibling tools like check_item_type_code and 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 its use case: when an agent needs the full set of item type identification codes. However, it does not explicitly state when to use this tool over check_item_type_code, nor does it mention exclusions or alternatives.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly implies a read-only listing operation and scopes results to MIME types for embedded attachments, but it does not disclose ordering, pagination, authentication, or other limitations. This is adequate for a simple zero-parameter list tool, 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 short sentence that front-loads the action and resource with no filler or repetition. Every word contributes to understanding 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 no-parameter list tool with an output schema, the description is nearly complete: it names the resource and scope. It lacks only an explicit pointer to check_mime_code for validating a single MIME type, which would strengthen sibling 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?

The tool accepts zero parameters, so there are no parameter semantics for the description to add. Schema description coverage is complete because the properties object is empty, matching the zero-parameter baseline.

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

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

The description uses a specific verb ('List') and identifies the exact resource ('recognized MIME types') with a qualifier ('for embedded attachments'). This clearly distinguishes it from other sibling list_*_codes tools, which target different code sets like VAT categories, payment means, or allowance reasons.

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 choose this tool over check_mime_code or the other code-list siblings. There are no stated conditions, exclusions, or alternatives, so the agent has to infer usage 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 provided, the description carries the behavioral disclosure burden. It reveals that the data source is a local, non-bundled eDEC GeneriCode export, that an environment variable is required, and that redistribution rights are uncertain. This adds meaningful operational context beyond the input 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 front-loaded with the purpose and follows with essential setup context. There is no redundant text; every sentence contributes necessary information, including the source, prerequisite, and licensing caveat.

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 tool with an output schema, the description covers the data source, prerequisite, and licensing context. It does not mention alternative tools, but the main operational requirements are present, making it sufficiently 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 single parameter, 'active_only', is already fully described in the schema with its type, default, and behavior. The description adds no additional parameter semantics, so the baseline of 3 for high schema description coverage 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 clearly states a specific verb and resource: 'List Peppol participant identifier (ICD) schemes from the OpenPeppol eDEC code list.' This distinguishes the tool's subject matter, though it does not explicitly differentiate it from the similarly named sibling 'list_icd_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 provides a concrete prerequisite: EINVOICING_PEPPOL_CODELIST_DIR must point to a local eDEC GeneriCode export. However, it gives no guidance on when to prefer this tool over alternatives such as list_icd_codes or check_participant_id_scheme_in_codelist.

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 'List' clearly indicates a read-only enumeration operation, and naming the source code list adds useful context. There are no side effects, destructive actions, or auth requirements implied or hidden.

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. Every word adds value by identifying the code list, the specific code type, and the authoritative source.

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. An agent knows exactly what the tool returns and the source of the data. No additional context is needed to invoke it successfully.

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 parameter semantics are not a concern. No parameter-level information is needed, and the description sufficiently identifies what will be listed without requiring schema documentation.

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

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

The description states a specific verb ('List'), a specific resource ('UNCL4461 payment means codes'), and the source code list ('CEF EN 16931'). This clearly distinguishes it from the sibling check_payment_means_code and from other list_*_codes 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?

Usage is implied: this tool enumerates payment means codes while the sibling check_payment_means_code is presumably for validating or looking up a single code. However, the description does not explicitly state when to prefer this tool over the check alternative or over other code-list 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 burden of explaining prerequisites. It does disclose that EINVOICING_PEPPOL_CODELIST_DIR is required, which is useful and non-obvious. However, it does not describe error behavior, return structure, or the read-only nature beyond the verb 'List', leaving some behavioral gaps.

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

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

The description is two sentences, front-loaded with the core purpose, and includes only necessary prerequisite information. Every sentence earns its place with no repetition 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?

The tool has a simple schema, a single optional parameter, and an output schema, so minimal description is needed. The environment variable requirement is an important addition that makes the tool usable. It could be more complete by noting the relationship to the check counterpart, but this is a minor gap for a straightforward listing tool.

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

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

Schema description coverage is 100% for the single boolean parameter active_only, so the schema already fully documents its meaning. The description adds no additional parameter semantics, which is acceptable given the baseline of 3 when schema coverage is high.

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 action ('List'), the resource ('Peppol process identifiers'), and the source ('OpenPeppol eDEC code list'). It differentiates from sibling tools like check_process_id_in_codelist by indicating that this tool returns a list rather than validating a single identifier.

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 mentions the required environment variable and points to list_participant_id_schemes for reference, but it does not explicitly explain when to use this tool versus the sibling check_process_id_in_codelist. The usage context is partially implied by the name and sibling list, but not fully stated.

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It accurately describes a read-only listing operation, but does not mention whether the list is complete, sorted, or limited, nor what each returned item contains beyond what the output schema already covers.

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 informative sentence with no filler. The verb and subject appear first, and the source qualifier is presented immediately, making the purpose readable at a glance.

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 is sufficient. It names the exact code list source and action, and the output schema handles return value details, leaving no meaningful gap for an agent to invoke it incorrectly.

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

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

The tool has zero parameters and the schema description coverage is 100%, so the schema fully defines the input surface. The description reinforces that no input is needed by framing this as a simple enumeration, adding no necessary parameter context.

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

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

The description states a specific verb ('List') and resource ('UNCL1153 reference qualifier codes') and identifies the exact source (CEF EN 16931 code list). This clearly distinguishes the listing behavior from the sibling check_reference_qualifier_code and from other list_*_codes 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 no guidance on when to use this tool versus the nearby check_reference_qualifier_code or other list tools. It is implied by the name and sibling pattern, but there is no explicit context for selection.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose a significant dependency: the EINVOICING_PEPPOL_CODELIST_DIR environment variable. But it does not mention what happens if that directory is missing, whether the data is read locally, or any ordering/filtering behavior, so the behavioral picture is incomplete.

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: one states the purpose, the second states a requirement and points to a sibling for setup. There is no fluff and the most important information is front-loaded.

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

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

For a simple list-only tool with one optional parameter and an output schema, the description covers the essentials: the data source and the required environment variable. It does not explain when to prefer it over related codelist tools, but it is otherwise complete enough for an agent to invoke correctly.

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

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

The only parameter, active_only, is fully documented in the schema with its default value and effect. The description adds no parameter-specific meaning beyond that, so the schema already does the heavy lifting.

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

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

The description clearly states a specific verb and resource: it lists 'Peppol SPIS use case identifiers' sourced from the OpenPeppol eDEC code list. It is unambiguous, though it does not explicitly distinguish itself from sibling list tools such as list_process_ids 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 implies usage by naming the resource, and it adds a key prerequisite by requiring EINVOICING_PEPPOL_CODELIST_DIR, even pointing to list_participant_id_schemes for setup. However, it does not state when to use this tool versus alternatives or when not to use it, leaving some selection guidance 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 full burden. It discloses the operation (list) and the source code list, but does not mention behaviors such as whether all codes are returned, ordering, or potential size. The output schema likely covers return shape, but behavioral context beyond that is minimal.

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 that immediately states the action and scope. There is no filler, repetition, 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 zero-parameter list operation with an output schema available, the description is largely complete: it names the resource and authoritative source. It could be slightly more complete by explicitly noting that this is the enumeration counterpart to check_vat_category_code, but that 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 input schema has zero parameters, so there is nothing for the description to clarify about parameters. The baseline for a zero-parameter tool is 4, and the description correctly communicates that no input is needed.

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 specific resource ('UNCL5305 VAT category codes'), and the source ('CEF EN 16931 code list'). This clearly distinguishes it from the sibling check tool 'check_vat_category_code' and from other code-list listing 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 the tool is for enumerating VAT category codes, but it does not explicitly state when to use this list tool versus check_vat_category_code. The intended usage is inferable from the name and sibling set, but no direct guidance or exclusions 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?

No annotations are provided, so the description carries the behavioral burden. The verb 'List' implies a read-only retrieval and the source is specified, but it does not explicitly state that all codes are returned, any ordering behavior, or that there are no side effects. There is no contradiction, but the disclosure is minimal.

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

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

The description is one sentence and about 14 words, front-loaded with the verb and resource, and includes the acronym expansion without fluff. 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 simple zero-parameter list tool with an output schema present, the description is nearly complete: it states the resource and the relevant standard. A note that it returns the full code set or a pointer to check_vatex_code for single-code validation would make it fully complete, but those are 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 input schema has zero properties, so there are no parameters whose semantics need explanation, and schema description coverage is trivially 100%. This meets the baseline for a no-parameter tool with nothing missing.

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'), a specific resource ('VATEX codes'), expands the acronym ('VAT exemption reason'), and names the source code list ('CEF EN 16931 code list'). This clearly distinguishes it from sibling tools like list_vat_category_codes and check_vatex_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 intended use case is clear: when the full set of VAT exemption reason codes is needed. It does not explicitly mention when to use check_vatex_code instead or state any exclusions, but for a zero-parameter list tool the context is straightforward.

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 burden. It discloses the output fields (legal name, address, etc.) and the optional auth. But it does not mention error handling, rate limits, or what happens if the number is not found. Basic transparency is present but could be more comprehensive.

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

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

Four sentences, each serving a distinct purpose: purpose, input flexibility, output description, optional authentication. No wordiness, well structured, and front-loaded with the core action.

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 lookup tool with one parameter and an existing output schema, the description covers key aspects. It could mention error cases or prerequisites, but given the simplicity and the presence of an output schema, it is sufficiently 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 already describes the parameter, and the description adds valuable formatting details (prefix, dots/spaces) beyond the schema. Schema coverage is 100%, so baseline is 3; the extra formatting guidance raises it to 4.

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

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

The description clearly states 'Look up a Belgian enterprise number' against a specific database (BCE/KBO). It uses a specific verb and resource, and distinguishes well from sibling tools like generate_invoice_be or validate_invoice_be 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 provides input formatting guidance (with/without prefix, dots/spaces) and mentions optional environment variable for authenticated access. However, it does not compare to sibling tools or specify when to use this vs. check_peppol_participant_be. No explicit when-not or alternative instructions.

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 disclosure burden. It details the accepted formats, extracted fields, and exact success/error return shapes. It omits side-effect information, but parsing is inherently read-only, and the behavioral disclosure is sufficient for an agent to understand the tool's operation and error handling.

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 relatively concise, front-loading the core purpose in the first sentence. It avoids fluff but could be slightly tightened (e.g., the accepted formats are mentioned twice). Overall, it efficiently conveys the necessary information without extra verbiage.

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

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

Given a single parameter with full schema coverage and an output schema (assumed from context), the description covers the tool's function, input constraints, and return structure on both success and failure. It does not mention dependencies or prerequisites, but for a parse tool with no nested objects or complex parameters, this 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?

The input schema provides 100% coverage with a description for 'xml_content' as 'Raw UBL 2.1 XML invoice content (Peppol BIS 3.0)'. The description adds value by specifying that EU PINT v1.0.1 is also accepted, clarifying the parameter's scope beyond the schema. This extra context merits a score above the baseline 3.

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

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

The description clearly states the tool parses UBL 2.1 XML invoices into a structured dict, specific to Peppol BIS 3.0 or EU PINT v1.0.1 documents, and extracts EN 16931 fields plus Belgian extensions. This is a distinct task from siblings like validate_invoice_be (validation) or transform_to_ubl (transformation).

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 the input document types (Peppol BIS 3.0, EU PINT v1.0.1) and explains the return format, helping an agent decide when to invoke the tool. However, it does not explicitly contrast with siblings or state when not to use it, leaving some ambiguity about alternatives like validation or transformation.

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 present, the description carries the behavioral disclosure burden. It does well by stating that the search is public and unauthenticated, which is important for an agent deciding how to invoke it. It also clarifies that this is not an SMP lookup, preventing a subtle misuse. It doesn't discuss pagination or rate limits, but the output schema and parameter descriptions cover most operational details.

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 concise: three short sentences with no filler. It front-loads the core purpose, then adds the access mode and the essential parameter constraint. 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?

Given the tool has 8 parameters, a rich schema, and an output schema, the description covers the most important contextual gaps: public access, non-SMP scope, and the required-filter constraint. It could additionally name the sibling for SMP lookup, but the explicit 'no relation to SMP lookup' warning largely compensates.

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 adds meaningful value by specifying the non-obvious requirement that at least one of q/participant/name/country/doctype must be supplied, which is not enforceable in the schema since all parameters are optional. This helps the agent avoid calling the tool with no filters.

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 ('Search') and resource ('Peppol Directory', 'registered participants'), immediately clarifying what the tool does. It further distinguishes itself by explicitly stating it has 'no relation to SMP lookup', which separates it from sibling tools like peppol_lookup_participant.

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: this is a public, unauthenticated directory search. It also states a critical usage constraint: at least one of q/participant/name/country/doctype must be supplied. However, it doesn't explicitly name an alternative tool for SMP lookup, so the guidance stops short of fully routing the agent to the correct sibling.

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

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

With no annotations provided, the description carries full behavioral disclosure responsibility. It details the internal workflow (DNS resolution then service metadata fetch) and precisely describes the redirect edge case: `redirect_url` set, `endpoint_url` None, and a hard limit of one redirect hop per SMP 1.4.0 §3.2. This is explicit, operational context that goes well beyond the schema.

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

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

The description is two sentences with the primary action front-loaded and the critical redirect caveat placed immediately after. Every clause adds relevant information; there is no filler or repetition.

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

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

For a tool with three parameters and an output schema, the description covers the full workflow and a significant non-obvious edge case (redirect handling). It does not mention error behavior when DNS resolution or SMP fetching fails, but given the output schema exists and the parameter schema is complete, the core operational knowledge needed to invoke correctly 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 input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description references `document_type_id` in the workflow and contextualizes it as the target of metadata fetching, but adds no new parameter-level syntax or format details beyond what the schema 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?

The description opens with a specific verb and resource: 'Fetch the AS4 endpoint for a Peppol participant's document type.' It clearly states the tool's objective and distinguishes itself from sibling tools like resolve_peppol_dns by mentioning the DNS resolution step, making the tool's scope 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 purpose sentence implies the tool is for endpoint discovery, and the technical detail about DNS resolution suggests how it works. However, it does not explicitly name alternatives or state when to prefer this tool over similar siblings like resolve_peppol_dns or peppol_lookup_participant. A short 'use this when...' phrase would elevate 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does well by revealing that the tool performs network lookups (DNS-over-HTTPS and SMP requests) to determine registration status and document type identifiers, implying a read-only, non-mutating 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 concise and front-loaded: the first sentence states the purpose, and the second sentence explains the operational flow. Every sentence adds necessary information without repetition 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?

Given the presence of an output schema and full parameter documentation, the description is largely complete: it states the purpose, the lookup method, the determined outcome, and the identifier scope. It could be slightly more complete by noting when to prefer this over related Peppol lookup tools, but that is not a critical 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 input schema provides 100% coverage of both parameters: identifier and environment, each with clear descriptions. The tool description adds no additional parameter-level meaning beyond what the schema already states, 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 also clarifies the mechanism (DNS-over-HTTPS U-NAPTR lookup + SMP service-group request), making it easy to distinguish from siblings like resolve_peppol_dns or peppol_directory_search.

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

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

The intended use case is clear from the description: verify Peppol registration status and supported document types. However, it does not explicitly contrast itself with sibling tools such as peppol_get_service_endpoint, resolve_peppol_dns, or peppol_directory_search, so an agent must infer when this tool is the right choice.

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 goes beyond a simple 'sends an invoice' by disclosing the steps: SMP lookup, ebMS3/AS4 envelope construction, and credential use. It does not mention irreversibility or delivery side effects, but the transmission intent is explicit, making this reasonably 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?

Two clear sentences with no wasted words. The first sentence gives the essential purpose, and the second adds meaningful operational process detail. The description is well front-loaded and appropriately sized for the tool's complexity.

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 a high-stakes external transmission operation with 8 parameters. An output schema exists, so return values are covered, but the description omits useful preconditions such as SMP discoverability, environment selection, and the relationship between sender_id and the signing credentials. It also does not connect to related lookup tools like peppol_lookup_participant or peppol_get_service_endpoint, which could be prerequisite steps.

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 documents all 8 parameters with descriptions, so the baseline is 3. The description adds no parameter-level detail beyond referencing the supplied signing credentials, which map to certificate and private key params. It does not need to compensate for missing schema coverage because coverage is 100%.

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: 'Send a UBL/CII invoice to a Peppol participant via AS4.' It clearly identifies the operation and distinguishes it from invoice creation, validation, and lookup tools among the siblings.

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

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

The intended use is clear from the description: use this when an invoice document needs to be transmitted to a Peppol participant. It does not explicitly state when not to use it or name alternatives, but none of the sibling tools perform this exact sending function, so the context is sufficient.

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 burden and does well: it discloses that the tool is DNS-only, performs a raw U-NAPTR lookup, and explicitly does not fetch the SMP service group. This gives the agent an accurate model of side effects and limitations, though it does not discuss network dependency or error behavior.

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

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

The description is two tightly scoped sentences: the first states the core action, the second adds the key behavioral distinction and use case. No filler or repetition exists.

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-parameter tool with an output schema, the description is largely complete: it explains the operation, its scope, and its diagnostic purpose. It could slightly improve by naming a sibling alternative, but this is not required for correctness.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description reinforces what 'identifier' refers to implicitly via 'participant', but does not add new parameter-level detail beyond the schema. 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 names a specific verb ('Resolve'), resource ('SMP hostname for a Peppol participant'), and method ('via DNS only'). It further distinguishes itself from sibling tools by clarifying it performs the raw U-NAPTR lookup without fetching the SMP service group.

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 when to use it: for diagnosing SML registration independently of SMP reachability. It does not explicitly name alternative tools or when not to use it, but the context is strong enough that an agent can infer the appropriate scenario.

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

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

Discloses that no validation is performed, output format (xml, warnings), and non-fatal issues. With no annotations, but sufficient for a conversion 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?

Three sentences plus a bullet list. Front-loaded with core purpose, no wasted words.

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

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

For a single-parameter tool with output schema, description covers purpose, usage, behavior, return values, and references to sibling 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 covers 100% of parameter (data), description adds context about it being a structured JSON invoice and mentions output. Adds value beyond 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?

Clearly states it converts a structured JSON invoice to UBL 2.1 XML, with specific verb and resource. Distinguishes from sibling generate_invoice_be.

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

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

Explicitly states when to use (caller will validate separately) and contrasts with generate_invoice_be which does validation.

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 adds real behavioral detail: the two-stage pipeline ('XSD structural validation, then Schematron business rules') and a runtime requirement (the [xslt2] optional extra) that an agent needs before invoking. It does not describe failure behavior for invalid documents, but the output schema covers return values.

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

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

Two dense sentences: the purpose is front-loaded in the first, and the validation pipeline plus dependency note fit in the second with zero filler. Every clause earns its place.

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

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

With one fully-documented parameter, an output schema covering the return format, and a low-complexity read-only validation flow, the description covers the essentials. A note on validation-failure behavior or an explicit pointer to sibling validators would round it out, but nothing critical is missing.

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

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

Schema description coverage is 100% — report_xml_base64 is fully documented as 'Base64-encoded EUSR XML document.' The description adds no parameter-level detail beyond this, so the baseline 3 for high schema coverage applies.

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

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

States a specific verb ('Validate') and resource ('Peppol End User Statistics Report (EUSR) document'), and expands the acronym so the document type is unambiguous. The document-type specificity differentiates it from sibling validators such as validate_tsr_report, validate_mls_message, and invoice_validate without needing their schemas.

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

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

Usage context is implied by document type — use this when you have an EUSR document to validate — and the sibling list contains clear alternatives. However, the description never explicitly states when to choose this over validate_tsr_report or validate_mls_message, nor does it mention any prerequisites for the input.

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 full transparency responsibility and does so excellently. It discloses exactly what is checked (~50 BR-* rules), what is NOT checked (Peppol overlay, profile ID, EndpointID, narrowed code lists), the resulting metadata.scope, the warning behavior, and the risk of Peppol Access Point rejection. It also explains that mercurius only applies overlay rules, not full compliance.

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 long, but the length is justified by the complex tool behavior and the need to disclose significant limitations. The opening sentence provides a clear summary, and subsequent paragraphs are structured by profile. Slightly verbose, but every section contributes critical information.

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

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

Given the tool's moderate complexity, two parameters, an output schema, and no annotations, the description is comprehensive. It explains the validation scope, per-profile behavior, return structure, and references a design decision document. It covers both what the tool does and what it intentionally omits, making it complete for an agent.

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

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

Schema coverage is 100%, so the schema already describes both parameters. The description adds meaningful value by explaining what each profile actually does in behavioral terms: peppol-bis-3/pint-eu run EN16931 base rules, while mercurius runs only overlay rules. This goes beyond the enum labels and default value 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 uses a specific verb ('Validate') and resource ('UBL 2.1 XML invoice against Belgian business rules'), then immediately clarifies what is covered per profile. It clearly distinguishes itself from sibling tools like generate_invoice_be, parse_ubl_invoice_be, and transform_to_ubl, and explicitly states the scope limitations.

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

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

The description gives clear context for when the tool is appropriate: it covers EN16931 base rules for peppol-bis-3/pint-eu and Mercurius overlay rules for mercurius. It also states when it is NOT sufficient (not a full Peppol BIS3 conformance check). It does not explicitly name alternative tools to use for full conformance, but the profile-level guidance is strong.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals that Schematron validation is performed, that the optional xslt2 extra is required, and that full XSD validation is not covered. This is meaningful transparency beyond the schema, though it does not describe output details or error behavior.

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

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

The description is compact and front-loaded with the primary purpose. The additional sentences about Schematron rules and validation scope are informative without fluff, and every sentence earns its place.

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

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

The tool has a single parameter and an output schema, so the description does not need to detail return values. It adequately covers prerequisites and limitations, making it largely complete. It could be slightly stronger by noting typical usage context or alternatives, but not critically.

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

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

Schema description coverage is 100%, with mls_xml_base64 already documented as Base64-encoded MLS XML. The description adds context about Schematron validation but does not add parameter-specific semantics beyond the schema, so the baseline score 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 tool validates a Peppol Message Level Status (MLS) document, with a specific verb and resource. It also distinguishes the scope by noting Schematron validation and explicitly excluding full UBL XSD validation, which helps separate it from sibling validation 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 when to use the tool: to validate MLS documents via bundled Schematron rules. It notes that full UBL XSD validation is out of scope, which is a useful exclusion, but it does not explicitly name alternatives or state when to prefer sibling tools like validate_eusr_report or invoice_validate.

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 discloses the two-stage process (XSD structural validation followed by Schematron business rules) and the optional xslt2 dependency, giving agents important expectations about execution and requirements.

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 concise sentences with no filler. The first states the core purpose, and the second adds necessary behavioral detail about validation stages and dependency.

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, the description is nearly complete: it identifies the input type, the validation steps, and the dependency. It could optionally mention that validation is non-mutating, but that is strongly implied by 'validate'.

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 is already documented as 'Base64-encoded TSR XML document.' The tool description adds no additional parameter-level meaning, 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 resource: 'Validate a Peppol Transaction Statistics Report (TSR) document.' This clearly distinguishes it from sibling validation tools such as validate_eusr_report and invoice_validate by target document type.

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 tool name and description make the intended use unambiguous: this is the validation entry point for TSR documents. It does not explicitly name alternatives or state when not to use it, but the unique document type provides clear routing among sibling validation tools.

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