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

Annotations already indicate this is a write operation (readOnlyHint=false) and non-idempotent. The description adds no additional behavioral context such as required relation existence, uniqueness constraints, or what the API returns upon success. No contradiction exists, but no extra transparency is provided.

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

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

The description is short and mostly to the point, but the first sentence 'Create a new contact.' duplicates the title and adds no value. The API endpoint line is useful but not essential. It is acceptable but not optimally structured.

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 creation tool with no output schema, the description should at least hint at what the caller can expect (e.g., the created contact's ID or a confirmation). It also does not explain the 'linked to a relation' constraint or the role of the 'administration' parameter. This leaves gaps for a correct invocation.

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

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

The description does not mention any parameters or their meanings. Schema coverage is only 50% for top-level parameters, and while the nested ContactInput has detailed fields, the description fails to compensate for the gap by explaining key inputs like relation_id or the administration selector.

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 'Create a new contact person linked to a relation,' which clearly identifies the action and the resource, and distinguishes it from relation-level tools like create_relation. However, the first sentence repeats the title and there is no explicit differentiation from update_contact, so it loses a point.

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

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

The description provides no guidance on when to use this tool versus alternatives, and does not mention any prerequisites (e.g., the relation must exist before linking). It simply restates the function without contextual or exclusionary information.

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

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

The description discloses two behavioral traits beyond the annotations: the balancing requirement ('Debit and credit totals across all lines must be equal') and the optional invoice-linking capability. It does not disclose the side effect that a linked invoice's paid amount is updated automatically (buried in the schema's invoice_id description) or that dates must not fall within a locked period.

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 at roughly fifty words and front-loads the core purpose. It loses a point because the first two sentences are redundant: 'Create a new memorandum entry' and 'Create a new memorandum journal entry' say essentially the same thing, with the second merely adding 'journal'.

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 creation tool with a well-documented schema this is adequate, but with no output schema the return value is left to inference, and the description omits behavioral outcomes the agent should know: the automatic paid-amount update on linked invoices (only in the schema) and failure conditions such as unbalanced lines or locked-period rejections.

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?

Top-level schema coverage is only 50% since the body parameter lacks a direct description, but the nested MemorandumInput schema is rich with per-field descriptions, an example, and type+invoice_id pairing rules. The description adds the key debit=credit invariant and repeats the type+invoice_id pairing rule, reinforcing rather than significantly extending what the schema already documents.

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

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

The description uses a specific verb plus resource ('Create a new memorandum journal entry') and the word 'journal' differentiates it from invoice/receipt/order creation siblings. However, the opening sentence 'Create a new memorandum entry' simply restates the tool name and title, adding no information.

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

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

There is no explicit when-to-use guidance or named alternatives. The note that a line may optionally be linked to an existing sales invoice, purchase invoice, or receipt implies this tool handles manual journal postings with optional invoice linking, but the description never states when to choose this over create_sales_invoice/create_purchase_invoice/create_receipt or contrasts it with update/list_memorandum_entry.

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

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

Beyond the annotations, the description clarifies important behavioral semantics: amount is the gross amount and vat_amount is the VAT portion derived from it. It also identifies the exact endpoint path, adding context that the agent would otherwise have to infer.

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

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

The description is short and front-loaded, but it unnecessarily repeats 'Create a new purchase invoice' verbatim in the first two sentences. The endpoint line and semantic clarifications are useful, but the duplication prevents a higher score.

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 create operation with a nested object schema and no output schema, the description conveys the key prerequisite and the amount/VAT semantics. However, it does not mention response behavior, validation failures, or the optional nature of fields like collect and pdf, so complete guidance for invocation is still somewhat lacking.

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 description adds meaning beyond the schema by explaining that each line's amount is the gross amount and that vat_amount is the VAT portion of that amount. This nuance is not fully explicit in the schema and helps the agent compute or validate invoice lines correctly, even though many parameters are already well described 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 and resource: 'Create a new purchase invoice' and the endpoint 'POST /invoices/purchase'. It clearly identifies the object being created, though it does not explicitly contrast with sibling tools like create_sales_invoice.

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

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

The description gives an explicit prerequisite: call /invoices/purchase/options first to determine valid vat_id and ledger_id combinations. This provides actionable usage context, but it does not state when this tool should be preferred over alternatives or list 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?

The annotations already declare readOnlyHint=false and idempotentHint=false, so the 'Create a new quotation' statement is consistent with them. The description adds a validation step (options endpoint) and a jurisdiction-specific field requirement, but it does not describe response behavior or other side effects. It does not contradict the annotations.

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

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

The description is short but unnecessarily repeats 'Create a new quotation.' in the first two sentences, wasting a sentence. The remaining content is efficient and front-loaded with the most important prerequisite.

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

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

Given the rich input schema and the annotations, the description provides adequate high-level context with the options prerequisite and AT/DE condition. However, it does not reference the get_quotation_options sibling tool by name, nor does it describe the return value, which would make it more 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?

The schema describes several fields, but vat_option has no description. The description explains that vat_id, ledger_id, and vat_option must be validated via the options endpoint, which adds actionable meaning beyond the raw schema. The AT/DE delivery_date requirement is also useful, even though the schema already mentions it.

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

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

The description states 'Create a new quotation,' which is a specific verb-resource pair that clearly distinguishes it from sibling tools like create_sales_invoice or create_purchase_invoice. The additional context about /quotations/options and AT/DE delivery_date further confirms it is about quotations specifically.

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

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

It gives concrete preconditions: use the /quotations/options endpoint first to determine valid vat_id, ledger_id, and vat_option combinations, and the delivery_date requirement for AT/DE administrations. It does not explicitly mention alternatives like update_quotation, but the context is clear enough for an agent to know when this tool is appropriate.

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

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

Annotations already indicate readOnlyHint=false, so the mutation nature is known. The description adds no extra behavioral details such as required permissions, side effects, or rate limits. It doesn't contradict annotations, so the baseline of 3 applies.

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 contains a redundant duplicate sentence ('Create a new receipt.') that provides no additional value. While short, the repetition is unnecessary and wastes space.

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

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

Given the tool has a nested body schema and many sibling tools, the description provides almost no context beyond the endpoint. No information about required vs optional fields, example usage, or when to choose this over related create tools. The agent must infer everything from the schema.

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

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

The schema provides detailed descriptions for all properties inside the body object, even though the top-level body parameter lacks a direct description. The tool description itself adds no parameter guidance, but the schema's coverage is sufficient enough to not be a major gap. With 50% formal coverage, the description does not compensate, but the schema carries the weight.

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

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

The description clearly states the action 'Create a new receipt' with a specific verb and resource, and includes the endpoint for reference. However, it does not distinguish this tool from siblings like create_purchase_invoice or create_sales_invoice, so it doesn't fully earn a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The description merely repeats the tool's name and endpoint, offering no context about scenarios, prerequisites, 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?

Annotations already provide readOnlyHint=false, destructiveHint=false, and idempotentHint=false, covering the write nature and non-idempotency. The description adds a procedural note about checking option combinations but does not disclose the response format, potential side effects, or required permissions. It does not contradict the annotations, so a mid score is appropriate.

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

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

The description begins by repeating the title verbatim ('Create a new recurring invoice.') which is redundant. The subsequent information about options and line types is valuable and well-structured, but the duplication and the trailing '[Recurring Invoices] POST /invoices/recurring' line add noise. It is not overly long, but could be tighter.

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 rich input schema with many parameters and nested objects, but no output schema. The description provides critical guidance on line types and the prerequisite options call, but omits any information about the response or what happens after creation. Given the complexity of the operation and the lack of an output schema, a description that does not explain return values or follow-up actions is not fully complete.

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

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

The description adds meaningful context beyond the schema by explaining the difference between regular lines (qty, amount, vat_id, ledger_id) and info lines (info=true and description). It also mentions the dependency between vat_id, ledger_id, and vat_option, which is not immediately obvious from the schema alone. Schema descriptions are already detailed for many fields, but the description helps prioritize prerequisites.

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 'Create a new recurring invoice' with a specific verb and resource. It also explains the two line types (regular vs info) and references the options endpoint, which helps distinguish it from sibling tools like create_sales_invoice or create_purchase_invoice.

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

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

The description explicitly instructs to use the /invoices/recurring/options endpoint first to validate VAT/ledger combinations, providing a prerequisite step. It explains when to use info lines versus regular lines. However, it does not explicitly mention when not to use this tool or compare with alternatives, leaving some inference to the agent.

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

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

Annotations already indicate the operation is not read-only, not idempotent, and not destructive. The description adds valuable behavioral context: relation_number generation when omitted or 0, default values for invoice template and payment condition, and strict field requirements based on relation_type. This goes beyond the annotations and helps the agent understand side effects and constraints.

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 structurally organized with a clear opening, optional/required field notes, and type-specific rules. However, it redundantly repeats 'Create a new relation' at the start, adding no value. The core content is concise, but the duplication and slightly unstructured flow prevent a higher score.

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

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

The description covers essential context for a creation tool: what happens when optional identifiers are omitted, which fields are required or forbidden per relation type, and that defaults apply. The rich input schema provides detailed field descriptions and examples. There is no output schema to explain return values, but for a create operation the input constraints are the critical part. Minor gaps like error handling or authentication are not necessary given the annotations.

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 50%, meaning the schema documents many fields but not all. The description adds key semantic details for relation_number, sales_invoice_template_id, payment_condition_id, and the relation_type-specific required/forbidden fields. While it doesn't cover every parameter, the input schema already provides descriptions for most fields, so the description compensates reasonably for the coverage gap.

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

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

The description clearly states the tool's action: 'Create a new relation.' It distinguishes itself from siblings like update_relation and get_relation by its focus on creation. However, it repeats the phrase 'Create a new relation' twice and doesn't explicitly name sibling alternatives, so it's clear but not fully differentiated.

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: use this tool to create a new relation, with conditions for company vs private types. It does not explicitly state when not to use it or mention alternatives like update_relation for modifications. The guidance is implicit rather than explicit, so it earns a 3.

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

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

Annotations indicate a non-read-only, non-idempotent, non-destructive write operation. The description adds valuable behavioral context beyond the annotations: a prerequisite call to /salesbook/options, conditional requiredness of delivery_date for certain administrations, and the optional base64 PDF attachment. No contradiction with annotations exists.

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

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

The description repeats the opening sentence verbatim: 'Create a new salesbook invoice.' appears twice, wasting a sentence. The remaining content is useful but would benefit from tighter editing. This is not conciseness; it is redundancy.

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

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

For a complex POST tool with a nested body object and no output schema, the description provides essential preconditions (options endpoint, AT/DE delivery_date) but omits details like how the response is structured, common error cases, or how to construct the full body beyond hints. It is adequate but not comprehensive.

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 only 50% at the top level (body is undocumented). The description compensates by clarifying important parameter relationships: valid combinations of vat_id, ledger_id, and vat_option must be determined via an options endpoint, and delivery_date is conditionally required. It also restates the optional base64 PDF, though that is already in the schema.

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

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

The description clearly states 'Create a new salesbook invoice' with a specific verb and resource, distinguishing it from sibling tools like create_sales_invoice by the explicit 'salesbook' qualifier. The endpoint hint '[Salesbook] POST /salesbook' further anchors what the tool does.

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

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

The description provides concrete usage guidance: 'Use the /salesbook/options endpoint first to determine valid combinations of vat_id, ledger_id and vat_option.' It also notes the AT/DE requirement for delivery_date. However, it does not explicitly state when to prefer this tool over alternatives like create_sales_invoice, leaving that distinction 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?

Annotations already signal readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds context about prerequisites and line types, but it does not disclose response behavior, error scenarios, or permission needs. The guidance to call an options endpoint first is a useful behavioral nuance, but overall the description does not go beyond what annotations and common sense imply for a create 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 fairly concise and front-loaded with the main purpose, but it repeats 'Create a new sales invoice.' twice in consecutive sentences. The other sentences carry relevant operational details, but the redundancy wastes space and slightly undermines the efficiency.

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

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

Given the tool's complexity (nested line items, many validation rules) and the absence of an output schema, the description could be more complete. It covers key prerequisites and line structure but omits what the response will contain (e.g., the created invoice object or errors). The rich schema compensates for much of the payload detail, so this is adequate but not exceptional.

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 detailed with per-property descriptions, covering the body object thoroughly. The description adds high-value semantic guidance: the distinction between regular and info lines, and the mandatory delivery_date for AT/DE administrations. It also points to the options endpoint to resolve valid parameter combinations, which directly aids parameter selection beyond schema definitions.

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

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

The description clearly states a specific verb and resource: 'Create a new sales invoice.' It distinguishes itself from sibling invoice tools (e.g., create_purchase_invoice) and related order/quotation tools by explicitly naming the sales invoice resource. The additional endpoint reference reinforces the tool's 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 description provides concrete pre-usage guidance: call /invoices/sales/options first to determine valid vat_id, ledger_id, and vat_option combinations. It also notes country-specific requirements for AT/DE administrations. However, it does not explicitly contrast with alternative tools (e.g., create_purchase_invoice), so the usage context is clear but not fully exclusive.

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

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

Annotations already mark this as a non-read-only, non-idempotent mutation, and the description adds useful behavioral constraints beyond them: the trade-module prerequisite, the need to pre-validate VAT/ledger combinations, and the country-specific required field. It does not contradict the annotations and adds context without getting into response 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 compact and roughly front-loaded, but it opens with two identical sentences ('Create a new sales order.' repeated). That redundancy means not every sentence earns its place, which keeps it from being a 4 or 5.

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

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

For a complex creation endpoint with no output schema, the description covers the non-obvious prerequisites and conditional requirements needed to invoke it successfully. It omits response behavior, but the rich schema covers required fields and enums, so no critical invocation information is missing.

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

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

With only 50% schema coverage, the description compensates by explaining cross-parameter constraints not inferable from the schema: valid combinations of vat_id, ledger_id, and vat_option, and the AT/DE delivery_date requirement. The input schema separately documents the individual field meanings and required fields, so the combination 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 states the exact action and resource ('Create a new sales order') and includes the endpoint POST /orders/sales, so an agent can tell it apart from the get/update/list/send sales-order siblings. It is clear but restates the tool title without adding additional scope or explicit differentiation among the create_* siblings, so not a 5.

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

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

It gives actionable preconditions: the trade module must be active, the /orders/sales/options endpoint should be consulted first, and delivery_date is mandatory for AT/DE administrations. This is clear context for when to call the tool, though it does not explicitly list exclusions or compare with alternative tools.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds meaningful behavioral context beyond annotations by stating the file is 'permanently removed from storage' and showing the HTTP DELETE endpoint. This discloses the irreversible nature of the operation, which is valuable for an AI agent.

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 includes the important permanent-deletion warning plus the endpoint reference. The first sentence repeats the title, which is a minor redundancy, but overall the structure is front-loaded and economical. It does not waste space with unnecessary details.

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

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

For a simple delete operation, the description provides the essential context: what is being deleted, the fact that deletion is permanent, and the endpoint structure clarifying the ID roles. There is no output schema, but none is strictly necessary for a delete operation. Missing details like error behavior would be nice but are not critical for tool selection.

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 has 100% description coverage for all three parameters, including id, attachment_id, and administration. The description does not add any parameter-specific semantics beyond what the schema provides. Baseline is therefore appropriate because the schema carries the explanatory burden.

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

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

The description clearly states the specific verb 'delete', the resource ('document-specific attachment'), and the container ('sales invoice'). The phrase 'permanently removed from storage' further clarifies the nature of the operation. This distinguishes the tool from sibling upload/download attachment tools without ambiguity.

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

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

The description provides a clear context: this tool deletes a specific attachment from a sales invoice. It does not explicitly name alternatives or exclusions, but the targeted resource scope is clear and the operation is unambiguous. Because it lacks explicit when-not-to-use guidance, it is slightly below a perfect 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?

Annotations already cover read-only and idempotent safety, so the bar is lower. The description adds useful behavioral context: the response is base64-encoded, the content is exclusive to this endpoint, and both shared library and invoice-specific attachments are supported. This goes beyond annotations by explaining the response format and scope.

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

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

The description is two short paragraphs with the core verb and resource front-loaded. The first sentence repeats the title, but the second sentence packs essential facts efficiently, and the endpoint reference is a compact, useful addition. No unnecessary 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 no output schema, the description explains the base64-encoded response and the alternative of using save_path (via schema). It also clarifies the relationship between attachments and invoices. It does not mention how to obtain the attachment_id or handle errors, but for a simple download operation with annotations covering safety, the essential context 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 schema has 100% parameter coverage, so the baseline is 3. The description adds an implicit relationship constraint—the attachment must be linked to the invoice—which is not explicitly stated in the schema property descriptions. This clarifies the semantics of the id and attachment_id parameters beyond their individual type descriptions.

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

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

The description uses a specific verb ('Download') and resource ('invoice attachment'), and clearly states the scope: both shared library and invoice-specific attachments linked to the invoice. It also differentiates from the invoice GET endpoint by noting the file content is only returned here. This makes the tool's purpose unambiguous and distinct 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 description explains that the endpoint works for both attachment types and explicitly notes that the file content is not returned in the invoice GET response, which guides the agent away from the more general GET endpoint. However, it does not explicitly name alternatives like list_attachments or upload/delete attachment tools, so the guidance is clear context rather than an explicit when-to-use vs not-to-use.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to restate safety. It adds useful behavioral context by specifying what details are returned (address, contacts, tax IDs, active modules) and the endpoint. There is no contradiction with annotations.

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

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

The description is compact and front-loads the core purpose, followed by useful detail and the endpoint reference. The opening sentence 'Get administration details' is redundant with the title/name, which prevents a perfect score, but the overall structure is efficient.

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

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

For a simple read-only endpoint with one optional, well-documented parameter and no output schema, the description provides enough information to call the tool correctly and set expectations about returned content. It could explicitly mention list_administrations for wider enumeration, but that is not essential for invoking this tool.

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

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

Schema coverage is 100% and the single optional parameter is fully documented with an enum and description. The tool description adds no additional parameter guidance, but the schema already carries the necessary meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get details') and names the resource ('administration linked to this API key'), with concrete content such as address, contact information, tax IDs, and active modules. It is clear, though it does not explicitly contrast itself with the sibling list_administrations beyond the singular ownership framing.

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: this tool returns details for the administration associated with the API key, which distinguishes it from broader listing operations. It does not explicitly name alternatives or exclusions, but the usage context is sufficiently clear for a single-administration read.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the HTTP endpoint and the year/period scope but does not disclose additional behaviors like return format, pagination, or any limitations. Since annotations cover the key behavioral traits, a 3 is appropriate.

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

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

The description is short and gets to the point. It opens with the tool's purpose, then provides a one-sentence summary and an endpoint reference. Minor redundancy between 'Get balance sheet' and 'Get a balance sheet report' but overall 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 simple read-only report tool with complete schema and annotations, the description provides the essential purpose and parameters. However, it lacks any mention of when to use this versus the sibling get_column_balance_report, and it does not clarify what the returned report contains. Given the sibling ambiguity, this is a 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?

Schema description coverage is 100%, so all parameters (period, year_to, year_from, administration) are already documented in the schema. The description adds no semantic detail beyond what the schema provides. Baseline 3 is correct.

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

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

The description clearly states a specific verb ('Get') and resource ('balance sheet report') with scope ('for a given year range and period'), and the tool name matches its purpose. It does not explicitly distinguish itself from the sibling get_column_balance_report, but the term 'balance sheet' provides enough semantic separation.

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 on when to use this tool versus alternatives such as get_column_balance_report. The description only states what the tool does, not when to prefer it or what context it applies to. There is no mention of exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the endpoint path and reinforces that this is a report retrieval. No behavioral surprises are disclosed, but none are needed beyond the annotations; no contradiction exists.

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

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

The description is compact and the substantive sentence is helpful, but it opens with a redundant 'Get column balance.' that duplicates the title. The endpoint line is useful, though the first sentence could be removed without losing 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?

For a read-only report tool with fully documented parameters and safety annotations, the description is functionally complete for invoking the tool correctly. It lacks explicit return-format information, but no output schema exists and the agent can still call it successfully based on the provided details.

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 descriptions for all six parameters, including ranges and the administration enum, so schema description coverage is 100%. The description only restates that the report uses year, period range, and ledger account range, adding no meaningful detail beyond what the schema already provides.

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

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

The description uses a clear verb 'Get' and identifies a specific resource: a column balance (proef- en saldibalans) filtered by year, period, and ledger account range. It accurately describes the operation and is not a tautology, but it does not explicitly differentiate itself from the sibling get_balance_report tool.

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

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

The description implies usage when a column balance report is needed for given year, period range, and ledger account range. It provides no explicit guidance about when to choose this tool over alternatives such as get_balance_report, and no exclusions or alternative conditions are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, fully covering the safety profile. The description adds only the endpoint and confirms a read operation, consistent with annotations. It does not add context about not-found behavior, authentication, or response shape, but the annotation coverage lowers the burden.

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

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

The description is short, but 'Get a single contact.' and 'Get a single contact person by ID.' are redundant restatements of the same purpose. The endpoint line is useful, but the repetition wastes the front-loaded position and could have been merged into one sentence.

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

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

For a simple read tool with two params, no output schema, and strong annotation coverage, the package is mostly adequate. The main gap is the missing differentiation from get_relation and lack of guidance on when to use this tool over list/other get operations. Minor missing details like not-found behavior are tolerable at this complexity level.

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 both id and administration already well documented in the schema. The description adds no parameter-specific detail beyond restating 'by ID.' With full schema coverage, the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Get a single contact person by ID.' The endpoint '[Contacts] GET /contact/{id}' reinforces the exact operation. It doesn't explicitly distinguish contact from the sibling get_relation, which could be confused, but the 'contact person' phrasing provides partial 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 when-to-use or when-not-to-use guidance is provided. There is no mention of alternatives such as list_relations or get_relation, nor any condition that selects this tool over them. Usage must be entirely inferred from the name and generic 'by ID' phrasing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds that the operation returns the entry including all line items and shows the endpoint path, providing useful behavioral context beyond the annotations.

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

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

The description is short and front-loaded, with the core action in the first sentence. The endpoint line and the line-items detail add value, though the first sentence is slightly redundant with the title.

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 single-item GET tool with only two parameters and strong annotations, the description is complete enough for correct invocation. It states the line-item return behavior even without an output schema. Minor additional details about error behavior are not essential here.

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

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

The schema describes both parameters fully with 100% coverage, so the description does not need to add parameter details. It mentions the ID-based lookup, but this does not meaningfully extend the schema documentation. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Get a single memorandum entry' and clarifies 'by ID, including all line items.' This clearly distinguishes it from list_memorandum_entries and other mutation tools such as create_memorandum_entry and update_memorandum_entry.

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 retrieving one specific memorandum entry by ID, contrasting with listing operations. It does not explicitly state when not to use it, but the single-entry language and sibling tool names provide sufficient context for an agent to choose correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that line items are included, which is useful but not a major behavioral detail. No contradictions with annotations.

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

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

The description is brief and front-loaded, with the essential action and scope early. There is minor redundancy with the title repetition and the endpoint line, but the overall structure is efficient and easy to parse.

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

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

For a simple get operation with two well-documented parameters and read-only annotations, the description is adequate. It states the retrieval purpose, the ID parameter meaning, and the inclusion of line items. No output schema exists, but the description gives sufficient context for correct invocation.

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

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

Schema description coverage is 100%: both 'id' and 'administration' are fully described in the schema. The description does not add extra parameter meaning beyond what the schema provides, matching the baseline.

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

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

The description clearly states the specific verb 'Get' with a single purchase invoice resource, and explicitly includes line items. This distinguishes it from list_purchase_invoices and other related tools by emphasizing the singular 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 description implies usage: use this tool when you need a single purchase invoice by ID. However, it does not explicitly state when to prefer alternatives like list_purchase_invoices, nor does it provide conditions or exclusions. Usage context is clear but not fully explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds valuable behavioral context by specifying the exact type of data returned (VAT rates with compatible ledger accounts), which goes beyond what annotations provide. It also gives the API endpoint, offering additional transparency.

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

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

The description is concise with two sentences and an API path line. The first sentence 'Get purchase invoice options' is somewhat redundant with the title, but the second sentence carries essential information. Overall, it is well-structured and wastes little space, though the slight redundancy prevents a perfect score.

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

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

Given that there is no output schema, the description adequately explains what the tool returns (VAT rates with ledger accounts). The single optional parameter is fully documented in the schema. For a simple options-fetching tool, the description is complete enough for an agent to invoke it correctly without ambiguity.

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 fully describes the single optional 'administration' parameter with enum 'default' and a clear description. The description does not add any additional parameter semantics, but because schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description explicitly states it retrieves purchase invoice options, specifically 'the available VAT rates with their compatible ledger accounts for creating purchase invoices.' This is a clear verb+resource+scope that differentiates it from sibling tools like get_sales_invoice_options, which would focus on sales invoices.

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 preparing to create a purchase invoice by mentioning 'for creating purchase invoices,' but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. There is no explicit 'when to use' or 'when not to use' guidance, so the usage context is only implied.

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

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

注解已提供readOnlyHint=true、idempotentHint=true、destructiveHint=false，描述额外补充了返回base64字符串、可通过save_path写入文件，以及对应的REST端点。这些信息增加了注解之外的上下文，且与注解不矛盾。

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?

描述简短，包含一句核心功能说明和一行API端点信息。标题与第一句略有重复，但整体信息密度高，没有冗余填充，可快速把握要点。

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?

工具简单，参数完整且带描述，注解覆盖安全属性，描述说明了返回格式和可选的保存路径。虽然缺少输出schema，但base64和save_path已足够代理正确调用，没有明显信息缺口。

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覆盖100%，每个参数（id、save_path、administration）都有清晰描述。描述本身未额外解释参数，但schema已充分承担说明责任，符合基线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?

描述明确陈述了动词“Download”和资源“purchase invoice PDF”，并具体说明输出为base64-encoded string。与兄弟工具get_sales_invoice_pdf通过“purchase invoice”明确区分，无需打开schema即可理解用途。

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

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

描述未显式说明何时使用或何时不使用，但隐含了使用场景：当需要下载购买发票的PDF时。没有提及替代工具或排除条件，相比清晰给出when/when-not的基准有所欠缺。

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds context about line items and the GET endpoint, but it does not disclose error behavior or response shape beyond that.

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

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

The description is compact and front-loaded with the main purpose, and the endpoint and line-item detail are useful. The opening line repeats the title, so it is not perfectly zero-waste, keeping it from a 5.

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

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

For a simple get-by-ID tool, the description, annotations, and fully documented schema provide everything an agent needs to invoke it correctly. It identifies the endpoint, required ID, optional administration parameter, and the fact that line items are included in the result.

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

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

Schema description coverage is 100%, so the input schema already documents both parameters sufficiently. The description does not add new parameter-level meaning, but the baseline of 3 is appropriate because the schema carries the full burden.

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

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

The description uses a specific verb ('Get'), names the resource ('quotation'), and narrows the scope to a single item by ID, including line items. This clearly distinguishes it from sibling tools like list_quotations and create_quotation.

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

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

The description clearly conveys that this tool is for retrieving one quotation by ID, which establishes a clear usage context. It does not explicitly name alternatives or exclusions, but the by-ID requirement sufficiently differentiates it from list-oriented siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds the endpoint and the specific contents returned, but it does not add deeper behavioral context such as response shape, authentication needs, 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 compact and front-loaded with the key information about VAT rates and ledger accounts. However, the opening sentence simply repeats the tool title, which is slightly redundant but not damaging.

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 no output schema, the description does a reasonable job of explaining what the tool returns by naming VAT rates, compatible ledger accounts, and VAT options. It lacks detail on response format or errors, but the endpoint is simple, has no required parameters, and annotations cover the safety profile.

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 100% coverage for the single 'administration' parameter, including an enum and a clear description. The tool description does not need to repeat this and adds no additional parameter semantics.

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

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

The description states a specific verb and resource ('Get quotation options') and elaborates on the exact contents: VAT rates, compatible ledger accounts, and VAT options for creating quotations. This clearly distinguishes it from sibling get_*_options tools for other document types.

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

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

The phrase 'for creating quotations' implies the intended use case, but the description gives no explicit guidance on when to choose this over alternatives like get_sales_invoice_options or list_vat_options. No exclusions or alternative routing are mentioned.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds behavioral detail by specifying that the PDF is returned as a base64-encoded string, which is valuable and not present in the annotations.

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

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

The description is very short and to the point. The first line repeats the title, but the following sentences add value by explaining the output format and the endpoint. It is efficient without unnecessary fluff.

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

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

For a simple read-only download tool with full schema coverage and supportive annotations, the description is complete enough. It explains the output format (base64) and clearly identifies the resource, so an agent can invoke it correctly without additional details.

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 provides 100% description coverage for all three parameters. The description mentions base64 encoding, which relates to the save_path parameter, but does not add detailed syntax or default behavior 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 clearly states the verb 'Download' and the resource (PDF of a quotation) plus the output format (base64-encoded string). It distinguishes itself from sibling tools like get_sales_invoice_pdf or get_purchase_invoice_pdf by naming the specific entity 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 description provides clear context on what the tool does and implies when it would be used (whenever a quotation PDF is needed). It does not explicitly list exclusions or alternatives, but the purpose is specific enough that an agent would not confuse it with other PDF getters.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context such as return structure, error handling, or access requirements, so it does not go beyond what annotations provide.

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

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

The description is short but redundant: the first sentence 'Get a single receipt.' is essentially repeated by 'Get a single receipt by ID.' in the second sentence. The endpoint line adds some useful context, but the duplication wastes space and weakens clarity.

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

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

For a simple read-only tool with full schema coverage and rich annotations, the description is mostly adequate. It includes the endpoint path, which is helpful, but lacks any context about how this receipt retrieval relates to other receipt operations or what the caller can do with the result.

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 both parameters (id and administration) already documented clearly. The description adds no extra meaning beyond the endpoint path hint, so the schema carries the semantic burden; this meets the baseline for full coverage.

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

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

The description clearly states the verb 'get' and resource 'single receipt', so an agent knows exactly what operation this performs. However, it does not distinguish this from sibling get_* tools beyond the resource name, and it largely repeats the title.

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 on when to use this tool versus list_receipts, create_receipt, or update_receipt. There is no mention of prerequisites, typical use cases, or alternatives, leaving the agent to infer usage from the name alone.

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

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

Annotations already cover the safety profile with readOnlyHint, idempotentHint, and destructiveHint=false. The description adds useful context by noting that the response includes all line items and by showing the exact REST endpoint. It does not disclose error behavior or auth requirements, but annotations lower the burden.

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

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

The description is short and front-loaded with the core behavior, and the endpoint details are useful. However, the first sentence 'Get a single recurring invoice.' redundantly repeats the title before the more informative follow-up sentence.

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

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

For a simple single-resource GET with strong annotations and full schema coverage, the description provides enough information: required ID, optional administration, and the endpoint. It could be slightly more complete by explicitly directing collection needs to list_recurring_invoices, but this is not a blocking gap.

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

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

Schema description coverage is 100%, so both parameters are already well documented. The description reinforces that lookup is by ID but adds no meaning beyond the schema, meeting the baseline for schema-covered parameters.

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

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

The description clearly states a specific action ('Get') on a specific resource ('a single recurring invoice'), further clarified by 'by ID, including all line items.' This distinguishes it from sibling tools like list_recurring_invoices, which operate on collections, and update/create variants.

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

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

The description makes the usage context clear: use this when you need one recurring invoice identified by its ID. It does not explicitly name alternatives or exclusion cases, but the 'single... by ID' phrasing strongly implies the appropriate condition and separates it from list-oriented tools.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, fully covering the safety profile. The description adds minimal behavioral context by noting that per VAT rate the usable ledger accounts and vat_option values are returned, but this is more return-value detail than behavioral disclosure. No contradictions; the description aligns with annotations.

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

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

The description is front-loaded with the tool name and purpose, then details the usage. The only minor redundancy is the first sentence repeating the tool name/title, but the rest is concise and informative. The endpoint path is included, which adds practical value without being verbose.

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

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

For a simple read-only tool with one optional parameter and comprehensive annotations, the description is complete. It states the purpose, what will be returned, and how to use it. The absence of an output schema is mitigated by the explicit statement about the returned VAT rates, ledger accounts, and vat_options, making the tool callable without further context.

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

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

Schema description coverage is 100% for the single parameter, with the description 'The client administration to act on. Only one is configured: default.' already explaining the parameter fully. The tool description does not add extra semantics beyond what the schema provides, 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 explicitly names the resource ('recurring invoice options') and the action ('Get'), and further specifies exactly what the options consist of: VAT rates, compatible ledger accounts, and VAT options. This distinguishes it clearly from sibling tools like get_sales_invoice_options or get_purchase_invoice_options, as it is scoped to recurring invoices.

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 directly states the purpose: 'Use this endpoint to determine valid combinations of vat_id, ledger_id and vat_option when creating recurring invoices.' This provides a clear when-to-use instruction. It does not explicitly mention alternatives or exclusions, but the guidance is precise enough for an agent to select this tool over others.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds value by specifying the response scope (includes contacts, tags, custom fields) and the HTTP endpoint, which the annotations do not convey.

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

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

The description is concise and efficient, with the first sentence restating the title but the second adding specific behavior. The HTTP endpoint line is a useful reference, though slightly redundant. Overall, it is well-structured and easy to scan.

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

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

For a simple get-by-ID tool with rich annotations (read-only, idempotent), the description covers the response contents and endpoint. Without an output schema, it could be more explicit about return format, but the included fields offer sufficient operational context.

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

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

The input schema provides 100% coverage with clear descriptions for both 'id' and 'administration'. The description itself does not need to add parameter details, as the schema fully documents them, meeting the baseline requirement.

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 'Get a single relation by ID', identifying the specific verb, resource, and identifier. It mentions the included data (contacts, tags, custom fields), which distinguishes it from list operations and other resource-specific getters like get_contact.

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 relation ID and want that single record, providing no explicit when-not-to-use or comparison with sibling tools. Some context is derivable but no exclusions or alternatives are stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the detail that line items are included and shows the endpoint format, but does not disclose additional behavioral traits like pagination or response structure. This is sufficient given the annotation coverage.

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

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

The description is short and to the point, but the first sentence repeats the tool title exactly. The second sentence and endpoint reference add valuable detail. Minor redundancy prevents a perfect score, but overall it is efficient and front-loaded.

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

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

For a simple read operation with full schema coverage and safety annotations, the description provides enough context to invoke the tool correctly. It notes the ID lookup and inclusion of line items, which are the key details. Without an output schema, a bit more about return format would help, but this is not critical.

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 describes both parameters fully (id as integer, administration enum with 'default'). Schema coverage is 100%, so the description need not add parameter semantics. The description does not enrich parameter meaning beyond the schema, matching the 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 states a specific verb ('Get'), resource ('salesbook invoice'), and scope ('by ID, including all line items'). It clearly distinguishes this from other invoice-related tools by explicitly mentioning the inclusion of line items and the ID-based retrieval.

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

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

The description implies usage for retrieving a single invoice with line items, but does not explicitly state when to use this over the many sibling tools (e.g., get_sales_invoice, get_salesbook_invoice_pdf). No exclusions or alternatives are named, so the agent must infer the appropriate context.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. The description adds the endpoint method (GET) and the nature of the data returned, which is consistent with the annotations but does not disclose additional behavioral traits such as authentication requirements or response format.

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

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

The description is concise and well-structured: a one-line title (slightly repetitive with the tool name), a useful explanatory sentence, and the endpoint reference. There is minimal waste, though the first line could be merged but is acceptable.

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

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

For a simple, read-only options tool with one optional parameter and clear annotations, the description provides sufficient information about what the tool returns. No output schema exists, but the description outlines the content (VAT rates, ledger accounts, VAT options), making it 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 schema covers 100% of parameters with a clear enum and description for 'administration'. The description does not add extra meaning to the parameter, but it is not needed since the schema is self-explanatory.

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 (Get) and a specific resource (salesbook options) and elaborates on what is returned: VAT rates with compatible ledger accounts and VAT options. This sufficiently distinguishes it from similar option-fetching tools like get_sales_invoice_options or get_purchase_invoice_options.

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

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

The description implies the tool is used when needing salesbook invoice configuration options, but it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or context for selection among the many option-fetching siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds valuable context beyond annotations: it states the download returns a base64-encoded string and mentions the optional save_path behavior, which informs expected output handling. The endpoint path is also included, which is extra useful context.

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

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

The description is extremely concise: three short lines with zero filler. The first line restates the title but the second line provides the actionable definition, and the endpoint line adds precise reference. Every sentence earns its place.

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

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

For a simple read-only download tool with no output schema, the description adequately explains the returned format (base64) and the optional save-path behavior. Missing are potential error conditions or notes on file size limits, but these are not critical for basic invocation. The main gap is the lack of usage-versus-alternative 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 input schema has 100% description coverage, so all three parameters are already self-documenting. The description does not add new meaning to the parameters, though the base64-encoding mention indirectly clarifies the output related to save_path. Baseline of 3 is appropriate.

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

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

The description clearly states the action ('Download the PDF file attached to a salesbook invoice') and the resource (salesbook invoice PDF). It distinguishes this from sibling PDF tools like get_sales_invoice_pdf and get_quotation_pdf by explicitly referencing 'salesbook invoice'.

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 versus the many sibling PDF retrieval tools (e.g., get_sales_invoice_pdf, get_purchase_invoice_pdf). The description assumes the agent already knows it should be used specifically for salesbook invoices, without explicitly stating selection criteria or excluding alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the agent knows it's safe. The description adds 'including all line items' which is useful context about the response content. No mention of potential errors or prerequisites, but annotations cover the key behavioral traits.

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

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

Three short sentences, efficient. The repeated phrase 'Get a single sales invoice' appears twice (first line and second line), which is slightly redundant. But the structure is clean and front-loaded with the core 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 simple GET-by-ID operation with rich annotations and 100% schema coverage, the description is adequately complete. It doesn't describe response format, but no output schema is present; still this is a basic retrieval tool, and the description covers the essential behavior.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description says 'by ID' reinforcing the id parameter but adds no new detail about admin parameter. Baseline 3 is appropriate when schema covers everything.

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 clearly states 'Get a single sales invoice' with specific verb and resource, and adds 'by ID, including all line items' for specificity. It is distinguishable from sibling list_sales_invoices and update_sales_invoice, though doesn't explicitly name them.

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

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

The description implies when to use: when you need a single invoice by ID. No explicit exclusions or alternatives are mentioned, but the 'Get' verb and ID requirement make it straightforward. Sibling tools exist but no comparison 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context by specifying what the endpoint returns and how that output is intended to be used, which goes beyond the structured annotation 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 compact and informative, with the key purpose stated early and detail about usage and the endpoint path following. Minor redundancy exists in repeating 'Get sales invoice options', but it does not detract from clarity.

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

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

For a low-complexity read-only options endpoint with zero required parameters and no output schema, the description sufficiently explains what will be returned and why it matters. The endpoint path and intended use case are included, making it complete enough for safe invocation.

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

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

Schema coverage is 100% with a well-documented single parameter (administration) that has a constrained enum, so the schema carries the full semantic burden. The description adds no parameter-specific detail, which is acceptable given complete schema coverage.

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

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

The description clearly states the resource (sales invoice options) and the specific content returned: available VAT rates with compatible ledger accounts and VAT options. It doesn't explicitly contrast with sibling get_purchase_invoice_options, but the sales-specific scope makes the purpose unambiguous.

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

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

Provides explicit guidance: use this endpoint to determine valid combinations of vat_id, ledger_id, and vat_option when creating invoices. It lacks explicit when-not-to-use guidance or named alternatives, but the stated use case is clear and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds meaningful behavior by specifying that the PDF is returned as a base64-encoded string and mentions the endpoint, which is beyond the annotations. No contradictions found.

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 – a title line, a concise explanation of the output format, and an endpoint reference. There is slight redundancy between the title and the first sentence, but overall every sentence contributes information without fluff.

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

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

For a simple download operation with a fully documented schema and safety-bearing annotations, the description covers the essential behavior (base64 return, endpoint). It doesn't describe error cases or pagination, but these are less critical for a single-resource PDF fetch, and the absence of an output schema is acceptable here.

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 all parameters (id, save_path, administration) are already documented in the input schema. The description adds no extra parameter-specific meaning beyond what the schema provides, matching the baseline for high coverage.

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

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

The description clearly states a specific verb ('Download') and resource ('PDF of a sales invoice'), and notes the return format as base64. It distinguishes from siblings like get_sales_invoice by focusing on the PDF artifact, though it doesn't explicitly compare against other PDF tools (e.g., get_sales_order_pdf).

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: when you need the PDF version of a sales invoice, use this tool. However, there is no explicit when-to-use guidance or mention of alternatives (e.g., use get_sales_invoice for structured data), leaving the agent to infer from name and description.

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

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

Annotations already declare the read-only, idempotent, open-world, and non-destructive nature of the operation. The description adds useful behavior beyond that: the response will include all line items, and the trade module must be active. It does not describe error behavior, but the annotations lower the burden.

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

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

The first sentence 'Get a single sales order.' is redundant with the second sentence, which repeats the same idea with more detail. The endpoint summary and prerequisite are useful, but the duplication makes the definition less tight than it could be.

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

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

For a two-parameter read operation with strong annotations, the description provides the essential facts: resource type, ID-based lookup, inclusion of line items, and a module prerequisite. Even without an output schema, an agent has enough information to select and call this 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?

Input schema coverage is 100%, with descriptions for both id and administration. The description's 'by ID' aligns with the required id parameter but adds no meaningful detail beyond the schema. This matches the baseline for high schema coverage.

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

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

The description states the operation explicitly: 'Get a single sales order by ID, including all line items.' It names a specific resource, retrieval method, and scope, making it easy to distinguish from sibling tools such as list_sales_orders or get_sales_order_pdf.

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: this tool fetches one sales order by ID and includes line items. It also states a concrete prerequisite, 'Requires the trade module to be active,' which helps the agent decide whether the call is valid. It does not name alternatives explicitly, but the usage context is otherwise clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by stating the module requirement and previewing the response contents, which matters because there is no output schema.

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

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

The description is compact and ends with a useful endpoint reference. The opening line 'Get sales order options.' is redundant with the title, but the rest of the description earns its place with concrete content and a prerequisite.

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 optional parameter fully documented in the schema, annotations covering read-only behavior, and a description that explains what the response contains. No output schema is present, but the description adequately compensates by naming the returned VAT rates, ledger accounts, and VAT options.

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

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

The schema has 100% description coverage for the only parameter, administration, including its enum and meaning. The description does not need to add parameter details, and it does not; baseline 3 applies because the schema fully carries the parameter semantics.

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

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

The description states a specific verb and resource: 'Get the available VAT rates with their compatible ledger accounts and VAT options for creating sales orders.' It clearly distinguishes this from sibling tools like get_sales_invoice_options or get_quotation_options by anchoring it to sales orders and naming the returned data.

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

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

The description gives clear context for when to use the tool: when creating sales orders and needing VAT rates, compatible ledger accounts, and VAT options. It also includes a prerequisite, 'Requires the trade module to be active.' It does not explicitly name alternative tools or exclusions, but the context is clear enough.

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

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

Annotations already mark the operation as read-only, idempotent, open-world, and non-destructive. The description contributes additional behavioral context by stating the response is a base64-encoded PDF and exposing the REST endpoint; the save_path write behavior is left to the schema, which documents it.

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

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

The description is short and front-loads the key purpose and output format. The opening 'Get sales order PDF' sentence is redundant with the title and the endpoint line is optional context, but there is no real bloat.

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

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

For a simple read-only download with fully described parameters and rich annotations, the definition is largely complete: it states output encoding, target resource, and endpoint. There is no output schema, so the return-format statement is essential and present; error behavior is not described, but this is a minor gap.

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

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

Schema description coverage is 100%, so the parameters are already well documented and the description needs to add little. The description does not elaborate on id, save_path, or administration beyond the schema, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Download') and resource ('PDF of a sales order') and adds the output encoding ('base64-encoded string'). This clearly identifies the purpose and distinguishes it from sibling PDF tools such as get_sales_invoice_pdf or get_purchase_invoice_pdf by 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 description provides no when-to-use guidance, exclusions, or alternatives; it never explains when to choose this over a sibling PDF downloader. The purpose sentence implies a use case, but that is not explicit usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable context about the 'verify' side effect (calls the API per administration) and what information the result contains (alias and writability), going beyond the annotations without contradicting them.

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

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

The description is three sentences, each earning its place: main purpose, verify behavior, and pointer to the mutation sibling. Information is front-loaded efficiently with no redundancy.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description fully covers what the tool does, what the return includes, how to verify credentials, and how to make changes. Nothing essential is missing.

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

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

The only parameter 'verify' is fully described in the input schema (calls API once, defaults to false). The description restates this but adds no new meaning beyond what the schema provides, so baseline 3 applies.

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

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

The description states a specific verb ('List') and resource ('client administrations'), and specifies the output includes the alias and write permissions. It distinguishes itself from sibling tools like get_administration (fetching one) and open_setup (changing configuration), making its purpose unambiguous.

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

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

The description explicitly says when to use this tool: to list administrations and optionally verify credentials. It also clearly directs to open_setup for any modification tasks ('To change any of it ... use open_setup'), providing a direct alternative and exclusion.

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

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

Annotations already carry the safety profile (readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds the administration scoping context beyond the annotations but does not disclose additional traits such as pagination, response shape, or what counts as an attachment. There is no contradiction with the annotations.

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

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

The description is short and front-loaded, with only three brief lines. However, the opening 'Get all attachments.' repeats the title verbatim and adds no value, while the '[Attachments] GET /attachments' line provides marginal API-path detail. Minor redundancy prevents a 5.

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

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

For a simple tool with one optional enum parameter, no required inputs, no output schema, and rich safety annotations, the description covers the essential invocation facts: it lists all document attachments for the administration. The main gap is not clarifying whether returned attachments span all invoice/document types or how they relate to the sibling attachment tools, but this is minor for a list 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?

Schema description coverage is 100%; the single 'administration' parameter is already fully documented in the input schema with its enum and purpose. The description adds no new parameter-level semantics beyond echoing the administration scope, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Get a list of all available document attachments for this administration.' The scope clarifies it lists all attachments rather than invoice-specific ones, which implicitly distinguishes it from sibling tools like upload/download/delete_sales_invoice_attachment. However, it does not explicitly name any sibling to differentiate against, so it falls short of a 5.

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 on when to use this tool versus alternatives such as upload_sales_invoice_attachment, download_sales_invoice_attachment, or delete_sales_invoice_attachment. The scope statement 'for this administration' gives some context, but there are no explicit conditions, exclusions, or alternative routing to help an agent decide.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context that this returns a list of all cost centre accounts and mentions the underlying endpoint, but does not disclose additional behavioral traits such as pagination or ordering. Given annotation coverage, the description provides moderate added value.

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

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

The description is short and front-loaded with the core action ('Get all cost centre accounts'), followed by a clarifying sentence and an endpoint hint. There is slight redundancy between the first line and the second sentence, but overall every line contributes useful information without unnecessary verbosity.

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

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

For a simple list operation with only one optional parameter and no output schema, the description is sufficiently complete. It indicates the resource, scope (administration), and a direct API endpoint. No critical missing information such as authentication or prerequisites is expected for this read-only list tool, though pagination behavior is not mentioned.

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 'administration' is fully documented in the schema with an enum of 'default' and a description stating it is the client administration to act on. The description's phrase 'for this administration' aligns with the schema but adds no extra meaning beyond it. With 100% schema description coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get all cost centre accounts' and elaborates with 'Get a list of all cost centre accounts for this administration.' It uses a specific verb (get/list) and resource (cost centre accounts), distinguishing it from sibling tools like list_ledgers or list_journals. The endpoint reference further clarifies the intent.

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

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

The description implies the tool is used to retrieve all cost centre accounts for a given administration, but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or selection criteria. Since there are no directly competing sibling tools (no other cost-centre-specific tool exists), the implied usage is adequate but lacks explicit guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and side effects. The description adds that it targets a specific administration and includes exchange rates, which is context beyond the annotations but not a deep behavioral disclosure (e.g., pagination, result size).

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

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

The description contains three lines but the first two largely repeat the same idea ('Get all currencies' vs 'Get a list of all currencies...'). The API path line is informative but redundant. It is concise but not tightly structured due to duplication.

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

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

For a simple read-only list tool with zero required parameters and full schema documentation, the description sufficiently explains what is returned (all currencies with exchange rates for the administration). No output schema exists, but the description covers the essential return content. Minor gaps like pagination are not critical for this simplicity.

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

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

Schema description coverage is 100% for the single optional parameter, including an enum and a clear description. The tool description does not add further parameter-specific semantics, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('currencies'), and explicitly states the scope: 'configured for this administration, including exchange rates'. This clearly distinguishes it from other list tools like list_administrations or list_relations.

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

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

The description implies its use for retrieving currency data but does not provide explicit when-to-use guidance or mention alternatives. While the intent is clear, there is no direct comparison to sibling tools or conditions for choosing this 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds useful context by specifying the HTTP endpoint and the administration scope. However, it does not disclose response format, pagination behavior, or any limitations beyond 'all journals', leaving the description to carry some weight but not much beyond the annotations.

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

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

The description is short and front-loaded with the main purpose, then adds the scope and endpoint. There is minor redundancy between 'Get all journals' and 'Get a list of all journals', but it remains efficient and easy to scan.

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

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

For a simple, non-destructive list operation with a single fully documented optional parameter, the description conveys the essential behavior: return all journals for the administration. No output schema exists, but the description states the result is a list of journals, which is sufficient for basic invocation. It could mention return structure or pagination but this is a minor gap.

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

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

Schema description coverage is 100%, and the single administration parameter is fully documented with type, enum, and a clear description. The tool description adds no additional information about the parameter, so the baseline of 3 applies.

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

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

The description clearly states the action ('Get a list'), the resource ('all journals'), and the scope ('for this administration'), and includes the HTTP endpoint 'GET /journals'. It is specific enough to identify the tool as a list operation on the journals resource, though it does not explicitly differentiate itself from sibling list tools beyond the named resource.

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 says what the tool does but provides no guidance on when to choose it over alternatives such as list_ledgers or other list_* tools. There is no mention of prerequisites, exclusions, or which sibling tools are preferable in other contexts.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds minor context about the content of the response (VAT codes, cost centre settings, etc.) but does not disclose behaviors such as pagination, error conditions, or authentication requirements. It does not contradict the annotations.

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

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

The description is short and mostly efficient, with the second sentence providing valuable details about included fields. However, the first sentence exactly repeats the title, adding no new information. The structure is still compact and front-loaded, so it earns a 4 rather than a 5.

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

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

Given the tool's simplicity (one parameter, no nested objects) and strong annotations, the description is mostly adequate. It clarifies the scope and content of the response but does not describe the output structure or mention any potential limitations (e.g., pagination). For a simple list operation, this is a minor gap, so a 4 fits.

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 has 100% description coverage for its single parameter, administration, which includes an enum and clear description. The tool description adds no extra meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'all ledger accounts (chart of accounts)', and further specifies what is included (VAT codes, cost centre settings, RGS codes, condensation codes). This unambiguously differentiates it from sibling tools like list_currencies or list_journals based on resource 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 description implies usage by stating 'Get all ledger accounts for this administration', but it does not explicitly state when to use this over alternatives. There is no mention of when not to use it or reference to a sibling tool. The intended use is clear but only implicitly conveyed through the resource 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds context about pagination and inclusion of line items, but does not disclose additional behavioral traits like rate limits or default page size. No contradiction.

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

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

The description is short but includes a redundant first sentence ('Get a list of memorandum entries') that repeats the title, plus a code-path line. The core second sentence is clear and front-loaded, but the redundancy prevents a higher score.

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

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

For a read-only list operation, the description plus annotations and schema cover the essentials: what it returns (paginated list with line items) and all optional pagination parameters. However, no output schema exists and the description does not explain pagination defaults or response shape beyond line items, leaving a moderate 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?

Schema description coverage is 100%; each parameter (page, records, administration) already has a description. The tool description adds no parameter-specific meaning, so baseline 3 applies.

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

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

States 'Get a paginated list of all memorandum journal entries with their line items' – a specific verb (get list), resource (memorandum entries), and scope (all, with line items). Clearly distinguishes from sibling get_memorandum_entry / create / update tools, so an agent can select appropriately.

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?

Description implies usage: use when you need a paginated collection of memorandum entries. It does not explicitly mention alternatives or when not to use (e.g., for a single entry use get_memorandum_entry), so guidance is clear context but without explicit exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that results are scoped to the administration but does not disclose pagination, result format, or other behaviors beyond the endpoint line.

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 brief and well-structured, with the API endpoint provided as a helpful anchor. The first sentence repeats the title, which is mildly redundant, but overall it is efficient and front-loaded.

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

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

For a simple list operation with one optional parameter and no output schema, the description covers the essential purpose and scope. It could mention result list semantics or pagination, but these are not critical for such a straightforward tool given the annotations.

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

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

Schema description coverage is 100% and the only parameter is well-documented with an enum and explanation. The description adds no extra parameter semantics, so the baseline of 3 applies given the schema's completeness.

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

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

The description clearly states the tool returns all payment conditions, with a specific verb and resource. It adds scope ('for this administration') but does not explicitly contrast with sibling tools, so it is clear but not fully differentiated.

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 on when to use this tool versus alternatives or when to avoid it. The description only states what it does, leaving the agent to infer usage context from the name and siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds beyond this: it specifies the return includes supplier information and states the module prerequisite. This is useful behavioral context that annotations do not provide, though it does not describe pagination 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 short but contains minor redundancy: the first sentence repeats the tool's title verbatim before expanding. The key details (supplier info, module requirement) are clear and the content is otherwise efficient.

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

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

For a simple parameterless-in-practice list tool with readOnly/idempotent annotations, the description provides essential prerequisites and return content. An output schema is absent, but the description notes supplier info inclusion. No critical missing information for correct invocation.

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

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

The input schema has 100% coverage with the 'administration' parameter fully described via its enum and description. The description's mention of 'this administration' aligns with the parameter but adds no additional semantic 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 states a specific verb ('Get'), resource ('products'), and scope ('for this administration'), and adds detail about included supplier information. This clearly distinguishes it from sibling tools like list_relations or list_sales_invoices, all of which target different resources.

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 indicates the prerequisite that the trade module must be active, giving the agent a concrete condition for when the tool can be used. It does not explicitly name excluded scenarios or alternatives, but among siblings there is no competing product-list tool, 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that results are paginated and include line items, which is useful context beyond the schema. However, it does not detail any quirks, rate limits, or response 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 short and front-loaded with the core purpose. The first sentence repeats the tool title, but the second adds concrete scope (line items) and the third provides the endpoint path. Minimal redundancy, clear 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 straightforward list operation with full parameter documentation and annotations covering read-only/idempotent behavior, the description is sufficient. It lacks details on default pagination behavior or return format, but the absence of an output schema and the simple nature keep the gap minor.

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 all parameters are already documented in the schema. The description adds no extra meaning beyond 'paginated' and 'with line items', which does not further clarify any specific parameter. Thus the baseline of 3 applies.

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

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

The description states a specific verb ('Get'), resource ('purchase invoices'), and scope ('paginated list of all purchase invoices with their line items'). It clearly differentiates from sibling tools like get_purchase_invoice by emphasizing the list and pagination, leaving no ambiguity about what the tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_purchase_invoice or list_sales_invoices. It only states that it lists purchase invoices; there is no mention of prerequisites, filtering scenarios, or when a different tool would be more appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the description only needs to add meaningful behavioral context. It adds pagination behavior and notes that line items are included, which is useful beyond the structured annotations. There is no contradiction with the annotations.

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

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

The description is short and front-loads the core purpose. The opening sentence mostly repeats the title, and the endpoint notation adds minor value, so it is not perfectly lean, but it remains concise and well-structured overall.

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

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

For a simple list tool with no required parameters and a fully documented schema, the description adequately covers purpose, pagination, and response content. It could mention default page size or records-per-page behavior, but nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, meaning all seven parameters are already documented in the input schema. The description does not add parameter-specific meaning beyond indicating that the list includes line items, so the baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Get') and resource ('quotations'), then further specifies 'a paginated list of all quotations with their line items.' This distinguishes it from sibling tools like get_quotation or list_sales_invoices by making both the resource and the list behavior explicit.

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 phrasing 'Get a paginated list of all quotations' implies this tool is for enumerating multiple quotations rather than retrieving a single one, but it does not explicitly name alternatives or state when not to use it. The usage context is implied by the resource and list semantics rather than spelled out.

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