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

The description repeats the idempotentHint and mentions it creates data, but the claim that it creates receipts, transactions, etc. is inaccurate for an accounts_add tool, misrepresenting its behavior. This reduces 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 repeats 'Add a basic account' and includes a lengthy generic first sentence that is not specific to this tool, making it somewhat verbose and less concise.

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

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

For a tool with 6 parameters and no output schema, the description is insufficient. It does not explain what a basic account is, how it differs from other account types, or what the result looks like.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no parameter-level details 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 clearly states 'Add a basic account' but the preceding generic statement 'Creates new records (receipts, transactions, postings, invoices, master data)' is overly broad and misleading, confusing the tool's actual purpose.

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

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

No guidance on when to use this tool versus siblings like 'accounts_get' or other account-related tools. No prerequisites or business context 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 provide readOnlyHint, idempotentHint, and destructiveHint. The description adds 'Fetches data. Makes no changes.' and 'get all the accounts', which clarifies scope (all accounts) but adds no new behavioral traits beyond 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 contains redundancy: 'get all the accounts' appears twice. The first line with emoji is unnecessary. It could be more concise without losing 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 get-all tool with one optional param and no output schema, the description covers the basic function. However, it omits details like return format, pagination, or filtering capabilities, which would help given the lack of an output schema.

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

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

The input schema fully describes the single optional parameter (api_key) with good detail. The tool description adds no parameter information, so it provides no additional value beyond the schema.

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

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

The description clearly states 'Fetches data' and 'get all the accounts', indicating it retrieves all account records. However, it does not differentiate itself from other get tools like cost_locations_get or postings_get, relying solely on the tool name for distinction.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., if only a subset of accounts is needed). The description only emphasizes read-only nature, which is already covered by annotations.

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 complements annotations by stating 'Not idempotent — calling twice may create duplicates', which is consistent with idempotentHint=false. It also indicates a write operation (readOnlyHint=false, destructiveHint=false). No contradictions; it adds useful duplication warning 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 relatively short and front-loaded with the purpose after a brief generic note. Each sentence serves a purpose: write warning, core function, parameter constraint. The generic WRITE note could be considered redundant if common across tools, but overall it is concise.

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

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

Given 4 parameters fully described in schema and no output schema, the description covers the key constraint. However, it lacks information on return values, error behavior, or expected response after adding a comment. While the tool is simple, an agent might benefit from knowing what to expect post-call.

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?

While the input schema describes all 4 parameters (100% coverage), the description adds critical constraint: 'You have to submit either a transaction_id_by_customer or a receipt_id_by_customer.' This mutual exclusivity is not evident from individual parameter descriptions, adding significant value.

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 'add comment to transaction or receipt', providing a specific verb and resource. The note about needing either transaction_id_by_customer or receipt_id_by_customer further clarifies the scope. This clearly distinguishes it from sibling tools like accounts_add or receipts_add.

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 includes a clear note about the requirement to submit either a transaction_id_by_customer or a receipt_id_by_customer, providing necessary context for when to use this tool. However, it does not explicitly mention when not to use it or compare to alternatives, but the constraint is sufficient for an agent to 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 indicate readOnlyHint=false and idempotentHint=false. The description explicitly states 'WRITE · creates data' and warns 'Not idempotent — calling twice may create duplicates,' adding useful behavioral context beyond 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 reasonably concise but includes a generic introductory line that is not specific to this tool, adding minor redundancy. The structure is acceptable but could be more focused.

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 the basic purpose and non-idempotence, but lacks details on return value, uniqueness constraints for code or name, and does not leverage the absence of an output schema to explain expected response.

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 detailed parameter descriptions. The description does not add any extra parameter information beyond what the schema provides, so it meets but does not exceed 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 'Add a new cost location.' The title also specifies the tool's function. However, it does not differentiate from sibling tools like cost_locations_update or cost_locations_delete, and a generic intro line about creating records is included but not specifically tied to cost locations.

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. The only behavioral note mentions non-idempotence, but there is no context on prerequisites, conditional use, or when to avoid it.

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

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

The annotations already indicate destructive and non-read-only behavior. The description adds meaningful context beyond that: cost-location deletes are not restorable, and the user should confirm before calling. The irrelevant 'cancelling a posting' reversal detail reduces clarity, but the core irreversibility disclosure is valuable.

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 not concise: 'delete cost location' is repeated in the bold heading and again in the sentence 'Delete a cost location.' It also includes generic receipt and posting cancellation behavior unrelated to cost-location deletion. The destructive warning is front-loaded, but the redundancy and irrelevant content hurt.

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 destructive two-parameter tool, the description covers irreversibility, user confirmation, and the endpoint. However, there is no output schema, and the description does not explain expected success or error responses. The irrelevant receipt/posting details also make the overall guidance less complete for this specific tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-level meaning beyond what the schema already provides for 'code' and 'api_key'. The endpoint information is useful but does not clarify 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 clearly states 'Delete a cost location' and the title reinforces the resource. It is distinct from cost_locations_get/add/update and from restorable receipt deletes. However, the opening 'Deletes or cancels a record' and the unrelated receipt/posting examples add ambiguity about what this specific 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 no explicit when-to-use guidance or routing among alternatives. It only warns to confirm with the user before calling. It does not say, for example, to use this when a cost location must be permanently removed, or to use cost_locations_update if changes are needed instead.

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

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

Annotations already provide readOnlyHint and destructiveHint; the description adds the POST endpoint and the 1000-limit, which are valuable behavioral details not in 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 succinct, uses emoji and bold for emphasis, and front-loads the read-only warning. No superfluous text, though it could be slightly more 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?

The description mentions the response includes row count and data array, but lacks detail about the fields in the array. Without an output schema, more specificity would improve completeness.

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 good parameter descriptions. The description only reiterates the limit constraint, adding no new semantic meaning beyond the schema.

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

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

The description clearly states the tool is read-only and fetches cost locations for a customer account, distinguishing it from write siblings like cost_locations_add/update/delete.

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 marks the tool as READ-ONLY and states its purpose, making it clear when to use it (to get cost locations without modification). However, it does not explicitly compare to alternatives.

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

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

The description adds context beyond annotations by stating 'Modifies existing master data in place' and including the endpoint. Annotations already provide idempotentHint=true and destructiveHint=false, and the description aligns with these.

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: one emoji line, one bold statement, and one sentence of purpose. Every word adds value, and it is front-loaded with the action and resource.

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 lacks details about the response (e.g., no output schema) and error conditions. However, for a simple update tool, it provides the essential purpose and parameters. More context on behavior when code is missing would improve completeness.

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

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

Schema coverage is 100%, so the description adds little beyond what is already documented. It reiterates 'name/description,' which matches the schema's parameter description. 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 'Update a cost location's name/description.' It uses the specific verb 'update' and identifies the resource (cost location), distinguishing it from siblings like cost_locations_add (create) and cost_locations_get.

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

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

The description implies usage for updating existing cost locations but does not explicitly state when to use this tool versus alternatives like cost_locations_add or cost_locations_delete. No guidance on exclusions or prerequisites 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=false and idempotentHint=false, and the description usefully makes the risk explicit: "Not idempotent — calling twice may create duplicates." That adds a small amount of practical behavior context, but the description otherwise does not disclose side effects, validation failures, or other runtime behavior beyond what annotations already imply.

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 it contains redundancy: "**create invoice**" repeats the title, and the opening list "receipts, transactions, postings, invoices, master data" is generic and potentially misleading for a tool specifically creating invoices. The duplicate-risk note and endpoint are useful, but the structure is not tightly focused.

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

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

For a tool with 33 parameters, 9 required fields, no output schema, and multiple closely related siblings, the description is too thin. It does not describe what the agent should expect in return, doesn't mention required fields, and doesn't guide selection between draft/e-invoice variants. An agent would need to inspect the full schema and sibling names to safely invoke this tool.

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

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

Schema coverage is 100%, so the schema itself documents all 33 parameters. The description adds no parameter-level meaning beyond schema fields, which is acceptable under the baseline for high schema coverage, but it also does not highlight which required parameters are central to a successful invoice creation call.

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 concrete action — "Add an invoice for the specified customer" — with a specific resource and endpoint. However, it does not distinguish this tool from sibling tools like invoices_create_draft or invoices_create_e_invoice, so it falls short of full differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives such as invoices_create_draft, invoices_create_e_invoice, or receipt creation tools. The generic "Creates new records" line implies broad creation but gives no selection criteria, prerequisites, or exclusion conditions.

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

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

Annotations already carry readOnlyHint=false and idempotentHint=false. The description confirms these with '🟡 WRITE · creates data' and 'Not idempotent — calling twice may create duplicates', and adds the endpoint. However, the generic line 'Creates new records (receipts, transactions, postings, invoices, master data)' is misleading here since this tool only creates an invoice draft, and much of the safety profile repeats 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 core sentence 'Add an invoice draft for the specified customer' is concise, but the description is padded with a generic template preface that repeats the WRITE signal and lists record types irrelevant to this tool. There is noticeable redundancy across 'creates data', 'creates new records', 'create invoice draft', and 'Add an invoice draft'.

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

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

This is a complex 30-parameter creation tool with no output schema and no guidance on how the many item arrays relate (e.g., parallel arrays). The schema is exhaustive at 100% coverage, so parameter semantics are covered, but the description omits return-value expectations, sibling differentiation, and any workflow hints. It is minimally viable but not complete for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter info in the tool description. The description adds nothing about parameters — it only mentions 'the specified customer', which is generic. The schema remains the authoritative source for parameter meaning.

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

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

The description clearly states the verb and resource: 'Add an invoice draft for the specified customer' and the heading 'create invoice draft'. This is specific enough to identify what the tool does. However, it does not explicitly distinguish it from sibling tools like invoices_create or invoices_create_e_invoice; one must infer that 'draft' is the differentiator.

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 given. The description never mentions alternatives such as invoices_create or invoices_create_e_invoice, nor does it explain what a draft is for compared to a final invoice. The only usage signal is the tool's own name, which does not count as 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?

Beyond the annotations, the description explicitly says the operation is not idempotent and that calling twice may create duplicates, which is a useful behavioral warning. It also labels the tool as a write operation and says it creates records. 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 front-loads the write/non-idempotency warning, followed by one specific sentence and the endpoint. There is minor redundancy in the generic 'creates data' prefix and the 'create e-invoice' heading, but overall it stays concise.

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

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

For a mutation tool with 35 parameters and no output schema, a single sentence is too thin. It does not describe the expected result/response, e-invoice-specific requirements beyond the schema, validation gotchas, or how this tool relates to sibling invoice tools. The rich schema covers parameters, but the description itself leaves significant context for the agent to discover.

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 parameter semantics are already fully documented in the input schema. The description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the operation: 'Add an e-invoice for the specified customer', with the endpoint POST /invoices/create/e-invoice. It is specific about the resource type (e-invoice) and action, but does not explicitly distinguish itself from siblings like invoices_create or invoices_create_draft.

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, and no alternative tools are mentioned. The agent is left to infer when an e-invoice is appropriate instead of a regular invoice or draft, and no mention of the typical public-contracting-authority use case is made.

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 adds the warning 'Not idempotent — calling twice may create duplicates' beyond the annotations, which declare idempotentHint false. However, it does not describe return values, error handling, or effects on other entities.

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 phrase 'add multiple free postings' is repeated verbatim, creating redundancy. The generic write warning at the start may not be specific to this tool, wasting 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?

No output schema is provided, and the description does not explain what the tool returns on success or failure. For a batch write operation, details on atomicity, partial success, or errors are missing.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds context that free_postings follow the same validation as the single-free-posting endpoint, but otherwise adds no new meaning beyond the schema.

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

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

The description states 'add multiple free postings' which is a specific verb-resource pair. However, it does not distinguish from the sibling 'postings_add_free' which adds a single free posting, relying on the name to imply batch operation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'postings_add_free' or other batch posting tools. The description does not mention prerequisites or 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?

The description explicitly labels it as a write operation (WRITE · creates data) and states it is not idempotent, which aligns with annotations and adds behavioral context. It also notes the prerequisite about activation. 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 includes an emoji and repeats the title in bold. The foreign currency note is useful but the structure could be tighter. Key information is front-loaded, but there is some 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?

The description lacks information about return values or error handling. For a write operation with nested objects, this omission leaves the agent uncertain about what to expect. Given no output schema, the description should compensate more.

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

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

Schema coverage is 100%, so the description adds limited value beyond schema. It mentions that the 'receipts' array structure mirrors the 'postings/add/receipt' endpoint, which is helpful but not detailed. 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 title and description clearly state the tool adds multiple receipt postings. The verb 'add' and resource 'postings' are specific. However, it does not explicitly distinguish this tool from the singular 'postings_add_receipt' or similar batch tools like 'postings_add_batch_transactions'.

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 important usage notes: only works if creditor/debtor posting is activated, and foreign currency handling requires pre-fetching the receipt. However, it does not guide when to use this tool versus alternatives (e.g., when to use batch vs singular).

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?

Description includes write indicator, creation of new records, and idempotency warning ('calling twice may create duplicates'), going beyond 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?

Front-loaded with write/behavioral warnings, but includes unnecessary formatting (emoji, bold) and endpoint URL, slightly impacting conciseness.

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?

Lacks output schema but covers key behavioral aspects (write, idempotency) and parameter structure via schema; no mention of error handling or partial success.

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%; description adds only a reference to another endpoint for validation details, not substantially enriching parameter meaning.

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

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

Title and description explicitly state 'add multiple transaction postings' and 'add posting for specified transactions', distinguishing from single transaction and batch receipts 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?

Description indicates it's for adding multiple transaction postings in batch, but does not explicitly state when to prefer this over sibling tools like postings_add_transaction.

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 this as a non-idempotent write operation. The description adds the concrete consequence that calling twice may create duplicates, which is useful behavioral context beyond the structured annotation. It does not cover validation or return behavior, but the duplicate warning adds real 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 write indicator, duplicate warning, action, and endpoint. The generic 'Creates new records (receipts, transactions, postings, invoices, master data)' boilerplate is somewhat unfocused, but overall the description is compact and readable.

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 schema fully documents the parameters and annotations cover mutation and non-idempotence. However, the description does not explain what a 'free posting' is, what a successful response looks like, or how this differs from sibling posting tools. It is minimally adequate but leaves notable gaps.

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

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

Schema description coverage is 100%, so all 9 parameters already have meaningful descriptions in the input schema. The description itself adds no additional parameter-level meaning, matching the baseline for fully documented schemas.

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 action clearly: 'Add a free posting' and provides the exact endpoint. However, it never explains what distinguishes a 'free' posting from the many sibling add tools, so it is clear about the verb and resource but not about sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as postings_add_batch_free, postings_add_receipt, or postings_add_transaction. No conditions, prerequisites, or exclusions are provided, so an agent cannot reliably decide between this and related 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?

Adds real behavioral context beyond annotations: flags WRITE, warns 'Not idempotent — calling twice may create duplicates' (expanding idempotentHint=false), and documents the activation and foreign-currency preconditions. No auth or rate-limit disclosure, but the dupicate-risk and prerequisite caveats are exactly the kind of value-add expected here.

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

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

Front-loaded with the WRITE warning and duplication risk, then the core action, then important prerequisites, then endpoint. Slightly bloated by the generic 'creates records (receipts, transactions, postings, invoices, master data)' line which describes the whole family rather than this tool, but overall compact and well-labeled with IMPORTANT markers.

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 10-parameter write operation with no output schema, the description covers the highest-risk aspects: non-idempotency, activation preconditions, and the foreign-currency retrieval workflow. The only real gap is return-value/response behavior, but annotations and the fully-documented schema carry much of the burden.

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% — every parameter (vats, amounts, postintexts, creditor/-debtor, api_key, cost_locations, etc.) already carries its own documentation in the input schema. The tool description itself adds no parameter-level detail beyond the foreign-currency note, 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?

States a specific verb and resource — 'Add postings for a specified receipt' — which clearly distinguishes it from siblings like postings_add_free, postings_add_transaction, and postings_add_batch_receipts. The receipt-scoped resource is unambiguous even before opening the schema.

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

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

Gives two concrete preconditions: receipt postings are only available if creditor or debtor posting is activated, and foreign-currency receipts require a preliminary /receipts/get/id_by_customer call to find the calculated amount. This is clear contextual guidance, though it never names alternatives or states when-not-to-use versus the other postings_add_* 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 readOnlyHint=false and idempotentHint=false. The description reinforces this by saying 'WRITE · creates data' and 'Not idempotent — calling twice may create duplicates', which adds a small behavioral warning. But it does not explain side effects, validation requirements, or whether an existing transaction must already exist.

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 write warning, but the first sentence is a generic boilerplate covering receipts, invoices, and master data — broader than this tool's actual purpose. The 'add transaction posting' line repeats the title, and the endpoint line adds little for an agent given the tool name and schema.

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

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

This is a complex 9-parameter, 6-required write operation with parallel arrays and many sibling tools. The description provides almost no workflow context, such as array alignment, required existence of the transaction, when oi_receipts_ids_by_customer is truly required, or what the consequences of a duplicate call are beyond a generic warning.

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 structured schema already documents each parameter in detail. The description itself adds no parameter-level meaning, which is acceptable under the baseline but does not improve understanding.

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

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

The description states a specific action and object: 'Add postings for a specified transaction.' This disambiguishes it from free/receipt posting tools. However, it does not call out the sibling batch variant or explain the array-based structure, so differentiation is only partial.

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 for when to choose this tool versus siblings like postings_add_batch_transactions or postings_add_free. There are no conditions, prerequisites, or exclusions 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?

The description discloses that the tool is a write operation ('WRITE'), can 'link/unlink records,' and is 'Reversible.' This adds context beyond annotations, but the description ambiguously mentions both creating and removing assignments while the tool name only suggests assignment. No additional details on permissions or side effects are 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 fairly concise but includes some repetition (e.g., the bold title line duplicates the purpose). It could be more streamlined by removing the general 'WRITE' note if it applies to a category, but overall it 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?

Given that there is no output schema, the description should at least hint at the return value or side effects of the assignment. It fails to explain what happens after assignment, error conditions, or any consequences, leaving the agent underinformed for a mutation 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 description does not add extra meaning beyond what the input schema already provides. The parameters are adequately described in the schema, so the description adds no additional semantic value.

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

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

The description clearly states the tool's purpose: 'Assign a receipt to a free posting.' It distinguishes from siblings like transactions_assign_receipt (which assigns to transactions) and postings_add_free (which creates a free posting). The verb 'assign' combined with the specific resource 'free posting' provides clear 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?

No explicit guidance is given on when to use this tool versus alternatives. Siblings such as transactions_assign_receipt and transactions_unassign_receipt exist, but the description does not explain that this tool is specifically for free postings or contrast it with other assignment 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?

It discloses substantial behaviorbeyond annotations: destructive semantics, the delete-vs-reversal distinction based on fixec status, restorability of related delete types, and the need to confirm with the user. This fully supplements the destructiveHint and readOnlyHint 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 front-loaded with the destructive warning, but the 'cancel posting' section repeats the same fixed-postings-deleted/reversal distinction already stated in the first paragraph. The redundancy makes it less concise 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 destructive mutation with no output schema, the description covers the critical behavior, confirmation requirement, and restorability nuances. It does not explain return values or define 'fixed', but it provides enough for an agent to call the tool correctly and safely.

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

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

Schema coverage is 100%, so the schema already documents both parameters adequaely. The description does not add meaning beyond 'specified posting' and the endpoint, giving no extra param 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 clearly identifies a specific verb ('Cancel') and resource ('a specified posting'), and distinguishes it from sibling operations like postings_unconfirm_* by stating that fixed postings are cancelled via a reversal posting while non-fixed ones are deleted. The endpoint and title reinforce the purpose.

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

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

The description implies use for cancelling postings and explicitly requires user confirmation before calling, but it does not contrast this tool with alternatives such as postings_unconfirm_* or the various delete tools. There is clear context, but no explicit exclusions or alternative routing.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, which the description reinforces. It also adds a key behavioral constraint: each request is limited to 1000 postings. 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 relatively concise with a front-loaded safety indicator. However, it includes minor redundancy (repeating 'get postings' and the endpoint) that could be trimmed without losing information.

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

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

The description explains the response structure (count and array) and the 1000 limit, but does not provide guidance on how to use pagination parameters (offset/limit) or specify which parameters correspond to 'customer account'. With 12 parameters and no output schema, more context would be helpful.

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

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

Schema coverage is 100%, so parameter descriptions in the schema are comprehensive. The description does not add new semantic meaning beyond what the schema provides, such as format or usage tips for individual 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 the tool retrieves postings for a specified customer account, using the verb 'get' and specifying the resource 'postings'. It differentiates from siblings by emphasizing the read-only nature, distinguishing it from write operations like postings_add_*.

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

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

The description implies the tool is for fetching postings based on the name and description, but it does not explicitly state when to use this tool over alternatives like transactions_get or receipts_get. No exclusions or prerequisites 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 provide destructiveHint=false and idempotentHint=true. The description adds context: 'Reverts a prior state change,' 'Reversible,' and the condition about 'not fixed.' It explains the idempotency implication (reversibility) but does not detail side effects or permissions. Adds value beyond 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 key information (write, reverts state) and ends with endpoint. Some redundancy with the emoji and bold formatting, but overall not verbose. Every sentence contributes meaning.

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

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

No output schema is provided, and the description does not explain the return value or error cases. For a simple write operation, the action is clear, but the lack of output description leaves a gap. Adequate but not complete.

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

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

Schema coverage is 100%, so both parameters are already documented. The description implies the use of posting_id_by_customer ('specified free posting') but does not add new semantic information. Baseline 3 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 the tool's action: 'Remove a specified free posting by unconfirming it.' It distinguishes from sibling tools like postings_unconfirm_receipt and postings_unconfirm_transaction by specifying 'free posting'. The verb+resource combination is specific and 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 provides a condition: 'This will only work if the posting is not fixed.' It implies usage for free postings but does not explicitly contrast with siblings. No when-not guidance, but the context of 'free posting' and sibling names makes it 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 indicate mutation (readOnlyHint=false) and idempotency. The description adds context: it reverts state, is reversible, and requires postings not fixed. No contradictions.

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?

Description is fairly concise with emoji and bold for emphasis, but includes some redundancy (e.g., 'unconfirm receipt posting' appears twice). Still efficient 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?

Given 2 parameters, no output schema, and available annotations, the description provides sufficient context: it explains the operation, condition, and endpoint. Lacks return value info but that's not expected without output schema.

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

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

Schema coverage is 100% with clear parameter descriptions. The description references receipt_id_by_customer but adds no significant meaning beyond the schema. Baseline 3 applies.

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

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

The description clearly states it unconfirms postings for a receipt, using specific verb and resource. It distinguishes from siblings like postings_unconfirm_free and postings_unconfirm_transaction by the resource type (receipt), but does not explicitly differentiate.

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

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

The description mentions a condition ('only work if postings are not fixed'), but does not provide explicit guidance on when to use this tool versus alternatives like postings_unconfirm_free or postings_unconfirm_transaction.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds that it reverts state and is reversible, which is consistent and provides behavioral context beyond 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 concise and front-loaded with the purpose and key conditions. It includes an endpoint and is well-structured, though the emoji and formatting could be slightly trimmed.

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 is a mutation with a specific condition, the description adequately covers the core behavior and condition. Without an output schema, the return value is not explained, but the tool's purpose is sufficiently clear.

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

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

Parameter descriptions in the input schema are complete (100% coverage), so the description does not need to add more. The tool description does not elaborate on parameters beyond what's in the schema, so 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 tool reverts a prior state change (unconfirms a posting) and specifies the resource (transaction postings). It distinguishes from siblings like postings_unconfirm_free and postings_unconfirm_receipt by focusing on transactions.

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 condition for use ('only work if the postings are not fixed') and states it is reversible. However, it does not explicitly compare to alternative tools or advise when not to use it.

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

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

Annotations indicate it is not read-only and not idempotent. The description adds context: 'Not idempotent — calling twice may create duplicates' and the 🟡 WRITE marker, which reinforces the behavioral traits and provides practical guidance.

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

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

The description is relatively concise, with a clear front-loaded warning about write operations and non-idempotency. The content is focused and efficiently conveys the necessary information, though the repetition of 'creates data' and 'not idempotent' could be slightly streamlined.

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 (14 parameters, no output schema) and the presence of many siblings, the description provides adequate context: it specifies the action, distinguishes the tool from 'receipts_upload', and includes behavioral hints. It does not cover all edge cases but is sufficiently complete for a creation tool.

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

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

Schema coverage is 100%, so the schema already documents all 14 parameters. The description does not add additional meaning about parameters beyond the schema details, thus 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 title 'Receipts: add a receipt' and description 'Add a receipt into the specified customer account' clearly state the verb (add) and resource (receipt). It distinguishes itself from sibling 'receipts_upload' by noting this endpoint is for adding without a file.

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 'Use this endpoint, to add a receipt without a file!', providing a clear condition for use relative to 'receipts_upload'. However, it does not address other scenarios 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 indicate non-idempotent (idempotentHint=false) and non-destructive (destructiveHint=false). The description explicitly states 'Not idempotent — calling twice may create duplicates', which adds value beyond annotations. It also notes the write nature and rate limit.

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

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

The description is front-loaded with a write warning and purpose. It is somewhat lengthy but structured logically: warning, title, purpose, rate limit. Could be more concise by removing the 'Endpoint' line, but overall 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?

No output schema is provided, and the description does not explain return values. It mentions error messages in the schema. The rate limit and non-idempotency are covered, but missing details on response format or success indicators.

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 detailed parameter descriptions. The description adds an extra constraint: 'maximum of 50 receipts are allowed', which is not in the schema. This fully compensates for the 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 'Creates new records' and 'add batch receipts / Add multiple receipts', specifying the verb (add) and resource (batch receipts). It distinguishes from sibling tools like 'receipts_add' (single) and 'receipts_upload'.

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

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

The description mentions a rate limit of one request per 5 seconds but does not provide guidance on when to use this tool vs alternatives (e.g., single receipt add or upload). No explicit when-to-use or when-not-to-use 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?

The description explicitly states 'READ-ONLY — Fetches data. Makes no changes', which aligns with and expands on annotations (readOnlyHint, idempotentHint, destructiveHint). No contradictions; adds beyond annotations by emphasizing safety.

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: a single line read-only note, a purpose sentence, a prerequisite hint, and the endpoint. Every sentence is essential, with no filler. The read-only indicator is front-loaded for instant 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?

Given the tool has no output schema, the description could mention the structure of the returned transactions for completeness. However, the description adequately explains what the tool does and how to use it, with the prerequisite step. It's nearly complete but lacks a brief note on response format.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining how to get the key parameter (receipt_id_by_customer via /receipts/get) and briefly noting the confirmed_only filter's effect, going beyond the schema's dry 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 clearly states the tool retrieves all transactions assigned to a specific receipt, using the verb 'get' and specifying the resource. It distinguishes from sibling tools like 'transactions_assigned_receipts_get' by focusing on the receipt-to-transactions direction.

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 prerequisite (obtaining receipt_id_by_customer via /receipts/get), offering clear context. However, it does not explicitly state when to use this tool versus alternatives like transactions_assigned_receipts_get.

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

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

With no annotations present, the description carries the full disclosure burden. It explicitly marks the operation as destructive, requires user confirmation, and notes that receipt deletes are restorable while cost-location deletes are not. It doesn't cover auth or linked-record effects, but it is more transparent than most delete tool descriptions.

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

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

The destructive warning is front-loaded and useful, but the description includes a bold heading that repeats the tool name and a generic 'deletes or cancels a record' passage with cancellation details that are not specific to this receipt deletion tool. It's serviceable but not tight.

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 deletes data and has no output schema or annotations, so the description should fully explain how to invoke it and what to expect. It leaves a critical gap: id_by_customer is central to the operation but is absent from the input schema, and no return behavior or post-delete effects are described.

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

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

The input schema already documents api_key well and coverage is 100%. The description adds useful guidance on obtaining id_by_customer, but that value does not appear as a parameter in the schema, so the added instruction is ambiguous about how the agent should supply 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 a specific verb and resource: 'Mark a receipt as deleted for a specified customer account by id_by_customer.' It clearly differentiates from sibling tools like receipts_get, receipts_get_id_by_customer, and receipts_restore_id_by_customer.

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

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

It gives explicit user instructions: confirm before calling and first get id_by_customer via the receipts/get method. It doesn't enumerate when-not-to-use alternatives, but the context is clear enough for a destructive delete tool.

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

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

The description explicitly states the tool is READ-ONLY and makes no changes, which reinforces the annotations. It also adds useful behavioral context beyond the annotations: the endpoint is a POST request, and the response includes a row count and an array of receipts data. This is meaningful extra information even though annotations already cover the safety profile.

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 important read-only signal, then gives the operation and endpoint. Minor redundancy exists because 'get receipts' repeats the title, but the description is not bloated.

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 schema and annotations carry most of the burden: all parameters are described and safety is clear. The description adds a high-level response summary and endpoint, but with 14 parameters, no output schema, and many sibling tools, it does not fully explain the overall invocation context or how this list endpoint fits with alternatives.

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

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

Schema coverage is 100%, so the parameters are already well documented. The tool description itself adds no parameter-level meaning beyond the schema, which matches the baseline for full 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 operation: get receipts for a specified customer account, and notes that the response contains a row count and an array of receipt data. It does not explicitly differentiate from sibling tools like receipts_get_id_by_customer or receipts_assigned_transactions_get, so it falls short of a full 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 given on when to use this tool versus alternatives. With many receipt-related siblings, the description does not explain why an agent should choose receipts_get over receipts_get_id_by_customer or receipts_assigned_transactions_get, nor does it mention any 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, openWorldHint, idempotentHint, and destructiveHint. The description repeats the read-only nature but adds minimal behavioral context beyond that (e.g., response returns an array of receipt data). It does not elaborate on rate limits, required permissions, or error conditions. The description adds little value over 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 somewhat verbose with repetitive elements (emoji, bold title, endpoint). It contains three sentences plus the endpoint line; some parts are unnecessary (e.g., repeating the tool name). Could be more concise 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 tool with no output schema, the description mentions that the response includes an array of receipt data but lacks details about receipt fields or pagination. It also does not summarize parameter purposes beyond what the schema provides. Given the tool's simplicity, it is marginally adequate but incomplete.

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 both parameters (api_key and get_file) fully described. The description adds no additional meaning or syntax details for these parameters beyond what the schema provides. Baseline of 3 is appropriate given 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 clearly states the verb ('Get') and the resource ('a single receipt for a specified customer account by id_by_customer'). It explains the need to first retrieve the identifier from another endpoint. However, the name and title are redundant and confusing ('id_by_customer' is awkward), and it does not explicitly contrast with siblings like receipts_get.

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

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

The description mentions how to obtain the required identifier ('using /receipts/get method first'), which provides a prerequisite. But it does not specify when to use this tool over alternatives (e.g., receipts_get) or when not to use it. No explicit when-to-use or when-not-to-use 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 indicate a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds context: 'WRITE', 'reverts state', 'reversible', and explains it restores a deleted receipt, aligning 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 somewhat verbose with redundant phrasing ('reverts state — Reverts a prior state change... Reversible'). It could be more concise while maintaining 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 restore tool with one optional parameter and no output schema, the description adequately covers the action, reversal nature, and how to obtain the identifier. Lacks discussion of error scenarios but is sufficiently complete for the complexity.

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 clear description for the only parameter (api_key). The description does not add parameter-specific information beyond what is in the schema, so it meets 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 action ('restore'), the resource ('deleted receipt'), and the identifier ('id_by_customer'). It distinguishes from the inverse sibling receipts_delete_id_by_customer by specifying it reverts a prior state change.

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 context ('Reverts a prior state change', 'Reversible') and tells how to get id_by_customer via /receipts/get, but does not explicitly state when to use this tool vs alternatives, nor when not to use it (e.g., if receipt is not deleted).

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?

Description adds context beyond annotations: it clearly states the tool is not idempotent (may create duplicates) and includes a rate limit. Annotations already indicate it's a write operation (readOnlyHint=false). No contradictions.

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, with a clear opening line distinguishing the tool type. The inclusion of the endpoint and rate limit adds value, though some repetition of the purpose exists. Could be trimmed slightly.

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

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

For a tool with 16 parameters and no output schema, the description explains the general purpose and response (filename), but does not summarize parameter interactions (e.g., e-invoice ignoring certain params) or provide more detail on processing. Adequate but not fully 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 100%, so the schema already documents all parameters thoroughly. The tool description does not add extra parameter-specific meaning, but 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 the tool uploads a receipt into a customer account, with a specific verb ('upload') and resource ('receipt'). It distinguishes from siblings like receipts_add by emphasizing file upload and processing by BuchhaltungsButler technology.

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

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

The description mentions a rate limit (10 requests per minute) and implies it is for file uploads, but does not explicitly state when to use this tool over alternatives like receipts_add or receipts_addBatch. No when-not or alternative names given.

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

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

Beyond annotations that already indicate a non-idempotent write, the description adds material behavioral detail: the report is generated asynchronousy, the response contains id_by_customer, and concurrent requests of the same type are restricted. This is exactly the kind of context agents need beyond annotation flags.

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 main body is relatively compact and includes endpoint, async behavior, and response info. However, the leading ' WRITE · creates data — Creates new records...' boilerplate is redundant with the title and annotations, and the bold 'create bwa report' heading repeats the tool name.

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

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

For a write tool with no output schema, the description conveys the response contract (id_by_customer), the asynchronous nature, and the single-flight constraint. It only stops short of explicitly naming reports_get_bwa as the follow-up retrieval tool, though that sibling is present in the list.

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 fully documents date_from, date_to, and api_key including formats and defaults. The description itself adds no parameter-level detail, 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 clearly states the action and resource: it 'Triggers the creation of a BWA report' and provides the endpoint. It is distinguishable from siblings like reports_create_sums by name and content, though the opening boilerplate about 'receipts, transactions, postings...' is generic and not specific to BWA reports.

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 provides one important usage constraint: a new report may only be requested after a previous report of the same type has finished generating. However, it does not explicitly tell an agent when to choose this tool over reports_create_sums or when to pair it with reports_get_bwa, leaving some usage routing to inference.

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

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

Beyond annotations (readOnly=false, idempotent=false), it discloses asynchronous generation, the id_by_customer response handle, and the one-at-a-time concurrency rule. The generic preface 'creates new records (receipts, transactions, postings, invoices, master data)' is not accurate for this specific report-creation tool and slightly undermines transparency, though it does not contradict 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 main content is well-structured with a bolded operation, short paragraphs, and endpoint. The opening 'WRITE · creates data — Creates new records...' line is redundant and partly off-target, but the rest of the description stays compact and action-oriented.

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

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

For a no-output-schema asynchronous creation endpoint, it covers the essential calling context: response contains id_by_customer, retrieval happens after generation finishes, duplicate creation is possible, and only one same-type report may be pending. The file/date parameters are already fully documented in the input schema, so no additional parameter detail is required.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond the schema; it only states the report period and that all postingaccounts are included, which relates to behavior rather than the individual 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 says 'Triggers the creation of a sums report' and names the German report type, so an agent can tell this is the sums-report creation endpoint rather than reports_get_sums. However, it does not explicitly contrast with sibling reports_create_bwa or retrieval endpoints, and the generic 'creates data — creates receipts/transactions/postings/invoices/master data' preface is broader and slightly distracting.

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

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

It gives clear context: the report is always for all postingaccounts, is asynchronous, and only one pending same-type report is allowed at a time. It does not explicitly say 'use reports_get_sums to retrieve the result' or 'use reports_create_bwa for a different report type,' but the constraints are enough to guide correct invocation.

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

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

Annotations already mark the tool as read-only/idempotent/non-destructive, and the description reinforces this with 'READ-ONLY — Fetches data. Makes no changes'. It adds valuable extra context about asynchronous generation and the replacement of a previously created report, which goes beyond the annotations. 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 compact and front-loads the safety statement, then states the operation, async timing, replacement caveat, and endpoint. There is slight redundancy between the bolded title 'get bwa report' and the action sentence, but no unnecessary clutter.

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 getter with three schema-documented parameters and no output schema, the description covers the key behavioral context: only fetch when generation is finished, and be aware that newer generation replaces the report. It doesn't describe the return payload shape, but no output schema exists and the tool is simple enough that 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%: all three parameters (api_key, get_files, report_id_by_customer) have descriptions in the schema. The tool description adds no parameter-specific meaning, so it stays at the baseline for fully covered schemas.

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 and resource: 'Returns a previously created BWA report'. This distinguishes the tool from creation siblings like reports_create_bwa, but it does not explicitly differentiate it from other report getters (e.g., reports_get_sums), leaving some ambiguity for the agent.

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 provides concrete usage context: the report must exist ('previously created') and generation is asynchronous, so it is only available after finishing. It also warns that creating a new report replaces the old one. It doesn't, however, name alternatives or state when not to use this tool versus other report 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value beyond annotations by disclosing the asynchronous generation behavior and that creating a new report of the same type replaces the previous one. This gives useful expectations about data availability and freshness.

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

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

The description is compact and front-loaded: the READ-ONLY emoji and safety note appear first, followed by a one-line purpose, then two essential behavioral caveats, and the endpoint. Every sentence earns its place with no filler.

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

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

For a simple fetch tool with full schema coverage and clear annotations, the description covers the key non-obvious aspects: async generation, report replacement, and endpoint. It does not describe the response format, but no output schema exists and the purpose is straightforward, so this is acceptable.

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 tool description itself does not add further parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the tool 'Returns a previously created sums report' with a specific resource type. However, it does not explicitly distinguish itself from the sibling reports_get_sums_ledger, which could be confused as another sums report variant.

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: the report must already exist, is only available after async generation finishes, and can be replaced by creating a new report. It does not explicitly mention when to prefer this tool over alternatives like reports_get_sums_ledger, but the usage context is strong enough for an agent to infer the right situation.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description's main added value is explaining that the ledger is generated on the fly, no report must be created beforehand, and large ledgers may take a while. This is useful behavioral context beyond the structured 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 reasonably compact and front-loads the read-only nature and the core purpose. There is some redundancy, such as repeating the tool name as a bold heading and restating read-only behavior already present in annotations, but it remains clear and scannable.

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 there is no output schema, the description provides the essential invocation context: what the ledger contains, where valid postingaccount numbers come from, the on-the-fly generation, and a performance caveat. It does not describe the exact output structure, but that is not strictly necessary for correct selection and 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 already documents all five parameters with useful details including date formats and api_key behavior, so the baseline is 3. The description adds meaningful guidance by telling the agent that valid postingaccount_number values can be obtained from reports/get/sums, which helps avoid invalid calls.

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 ('Returns') and the resource ('postingaccount ledger' / 'Kontenblatt') for one postingaccount. It also distinguishes this from the aggregated sums report by explicitly mentioning the report itself is created on the fly.

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 postingaccount numbers come from reports/get/sums, and contrasts this ledger with the report itself, implying when this tool is appropriate without needing to create a report first. It does not explicitly enumerate 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?

Description adds some context beyond annotations: indicates write operation and non-idempotence, but annotations already convey these. Adds some more specific record types.

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?

Description is short but includes a generic header line that could be trimmed. Overall 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?

Missing context on batch processing constraints (size limits, validation), no mention of return values or typical use cases.

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

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

Schema coverage is 100%, so baseline 3. Description does not add extra meaning about parameters beyond what schema provides.

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

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

Clearly states 'Create multiple creditor accounts' with specific verb and resource. Distinguishes from siblings like single creditor add and batch debtors.

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 on when to use this tool vs alternatives like settings_add_creditor or settings_update_creditor. Only mentions behavior, not usage 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 (readOnlyHint=false, idempotentHint=false) are consistent with the description's 'WRITE' and non-idempotency warning. The description adds context that it creates data, but includes a generic sentence listing other record types (receipts, transactions, etc.) which is inaccurate for this tool, slightly reducing 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 moderately concise but includes a generic template line that is irrelevant to this specific tool (listing other record types), which detracts from clarity. The bold header helps structure, but the generic part could cause confusion.

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?

No output schema exists, so the description should cover return values or response behavior, but it does not. It also lacks details on batch size limits, validation errors, or overall process flow. The generic sentence introduces ambiguity about the tool's scope.

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 detailed parameter descriptions. The tool description itself adds no additional parameter-specific information 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 explicitly states 'Create multiple debtor accounts' (specific verb and resource) and opens with 'create debtors batch', clearly distinguishing from sibling tools like 'settings_add_debtor' (single debtor) and 'settings_add_batch_creditors' (batch creditors).

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 warns about non-idempotency but provides no explicit guidance on when to use this tool versus the single debtor creation sibling ('settings_add_debtor'), nor does it mention prerequisites or scenarios where batch creation 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 non-idempotency and non-readOnly. The description explicitly states 'Not idempotent — calling twice may create duplicates' and marks the tool as 'WRITE · creates data', adding behavioral context beyond annotations. No contradictions.

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 an initial broad statement 'Creates new records (receipts, transactions, postings, invoices, master data)' which is misleading as this tool only creates a creditor account. This fluff reduces conciseness and clarity. The important non-idempotency warning is front-loaded.

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

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

Given 14 parameters and no output schema, the description covers the action and non-idempotency but omits return value details (e.g., does it return created creditor ID?). The endpoint is provided. The initial overbroad statement slightly detracts from completeness.

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

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

Schema coverage is 100%, so all 14 parameters have detailed descriptions. The tool description adds no additional parameter meaning, so it meets the baseline. No need for extra elaboration.

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

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

The description clearly states it creates a creditor account, distinguishing it from sibling create tools like settings_add_debtor or settings_add_postingaccount. The verb 'create' and resource 'creditor account' are specific, and the 'WRITE' label emphasizes mutation.

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 through its purpose but provides no explicit guidance on when to use this tool versus alternatives (e.g., settings_add_debtor). The non-idempotency warning is a caution but not a usage rule. No context of prerequisites or conflicting tools.

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

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

The description discloses that the tool is not idempotent and may create duplicates, which aligns with annotations (idempotentHint=false, readOnlyHint=false). It also indicates validation behavior for optional fields. This adds value 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 concise, with a brief generic header and two specific sentences. It is front-loaded with the write/duplicate warning, then the specific action. No unnecessary text.

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?

While the schema covers all parameters, the description lacks information about return values (no output schema) and any post-creation steps or prerequisites. For a creation tool with 14 parameters, more context would be helpful.

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 detailed descriptions for all 14 parameters. The tool description does not add additional meaning to the parameters beyond what is in the schema, so it meets the baseline expectation.

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 'Create a debtor account' and uses a specific verb-resource pair. The title and description clearly indicate this tool creates debtor records, distinguishing it from sibling tools like settings_update_debtor or settings_add_creditor.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as settings_add_batch_debtors for bulk creation or settings_update_debtor for modifications. Usage is only implied by the 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 indicate readOnlyHint=false and idempotentHint=false. The description adds a warning about duplicates from repeated calls, which is useful. However, it does not disclose potential side effects, required permissions, or return values, missing opportunities to fully inform the 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 relatively concise but includes a generic boilerplate line ('🟡 WRITE · creates data') that does not add tool-specific value. The specific part is short, but the structure could be tighter by removing redundant information.

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

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

With full schema coverage and a simple structure, the description adequately covers the purpose and non-idempotency. However, it lacks details on expected responses, error conditions, or typical usage patterns, leaving some gaps for the agent.

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

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

Schema coverage is 100% with clear parameter descriptions. The description adds no additional parameter-level meaning beyond what is in the schema, so it meets the baseline without adding value.

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 'Create a postingaccount' and mentions the endpoint, making the action clear. However, it does not differentiate from similar tools like settings_update_postingaccount, which might cause confusion about when to use create vs update.

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

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

No explicit guidance on when to use this tool versus alternatives. It mentions non-idempotency but does not compare to sibling tools like settings_add_creditor or settings_update_postingaccount, leaving the agent to infer usage from the tool 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 provide readOnlyHint=true and destructiveHint=false. The description adds 'READ-ONLY' and 'Makes no changes', which aligns but adds no new behavioral insights. There is a slight inconsistency: claiming 'Get all creditors' while supporting pagination, which is not explained. Beyond that, no additional behavioral traits are disclosed.

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

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

The description is short, with key info front-loaded in the first line. However, it repeats 'get creditors' (title, description, inline code) and includes an endpoint line that may not be essential. Still, it's efficient and avoids 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?

The tool has 3 optional params, no output schema. The description does not explain pagination behavior (limit/offset defaults, response structure). For a simple list tool, this might suffice, but it leaves gaps about how to retrieve all creditors and what the output contains. More detail on pagination and response would improve completeness.

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 has 100% description coverage: all three parameters have descriptions. The tool description adds no extra meaning to parameters; it merely restates the tool's purpose. Baseline is 3 because schema already provides sufficient semantic info.

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

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

The description clearly identifies the tool as fetching creditors with the phrase 'get creditors' and 'Get all creditors'. The title and emoji reinforce the read-only nature. The sibling tools include distinct actions like add/update, so differentiation is clear. However, the term 'all' contradicts the pagination parameters (limit/offset), slightly reducing clarity.

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

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

No explicit guidance on when to use this tool vs alternatives. The name and sibling set imply it is for reading creditors, not adding or updating. Usage context is implied but not stated, leaving ambiguity for an AI agent that might need to choose between get_creditors and add_creditor.

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 repeats the read-only nature already indicated by annotations (readOnlyHint=true) but adds no new behavioral traits. The endpoint method (POST) is a minor detail not found in annotations, but overall value is limited given annotation richness.

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, using only two lines plus an endpoint line. It front-loads the read-only nature and immediately states the action. Every sentence serves a purpose, with no extraneous content.

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

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

The description is minimal and lacks context about returns (e.g., a list of debtors) or pagination behavior. For a simple read-only tool with no output schema, it is adequate but leaves gaps in understanding the full scope.

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

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

Schema coverage is 100%, so the schema fully documents all three parameters. The description adds no additional meaning or explanation to parameters like limit, offset, or api_key, meeting the baseline expectation.

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 ('debitors'), making the tool's purpose unambiguous. However, it does not explicitly distinguish itself from sibling tools like settings_get_creditors, which limits contextual clarity slightly.

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. There is no mention of prerequisites, use cases, or exclusions, 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 declare readOnlyHint=true and destructiveHint=false. The description reinforces read-only behavior but adds minimal new insight beyond stating the method (POST) and the fact that no changes are made.

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 key action ('get postingaccounts') and read-only indicator. It includes an emoji for visual clarity but could be slightly more streamlined.

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?

Despite having 8 parameters and no output schema, the description does not explain return format, pagination behavior, or how the filter parameters (exclude_*) interact. This leaves significant gaps for an agent.

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

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

Schema coverage is 100% with detailed parameter descriptions. The tool description does not add any additional meaning or context for parameters 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 clearly states 'get postingaccounts' and 'Get all postingaccounts', making the verb and resource explicit. It distinguishes from sibling tools like settings_get_debtors and settings_get_creditors.

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 indicates read-only usage but does not provide specific when-to-use or when-not-to-use guidance relative to alternatives. It lacks explicit exclusions or alternative tool references.

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