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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as false, so the description's mention of 'safe' steps aligns but adds little new behavioral context. No contradiction found.

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

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

The description is very concise (two sentences), front-loads the core identity ('merged accounting inbox'), and uses minimal but effective words. It could be slightly expanded for clarity but is not wasteful.

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 6 optional parameters and no output schema, the description is minimal. It does not explain what 'safe next steps' or 'dry-run steps' produce, nor does it provide guidance on parameter usage beyond what the schema offers. Annotations fill some gaps, but completeness is only adequate.

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 all 6 parameters. The tool description does not add any additional meaning or context beyond what the schema already provides, so 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 it is a 'merged accounting inbox' and describes the two modes (scan, dry_run) with their actions. It distinguishes the tool's purpose from vague alternatives, though it does not explicitly differentiate from siblings like 'recommend_workflow'.

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 guidance on when to use each mode ('scan plans; dry_run runs safe dry-run steps'), but it does not specify when not to use this tool or suggest alternatives among the many sibling tools, such as 'classify_bank_transactions' or 'suggest_booking'.

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, and the description reinforces 'read-only analysis.' It adds behavioral context by listing the types of analysis performed, which goes beyond the 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?

Single sentence, front-loaded with 'Read-only analysis,' and every word adds value. No fluff or redundancy.

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

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

For a simple tool with 2 optional parameters and no output schema, the description covers purpose, nature (read-only), and output categories (duplicates, matches, transfers, patterns). Could mention date range or output format, but sufficient for typical use.

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 for both parameters, so the schema already documents their meaning. The description does not add new parameter-specific details beyond the schema, so baseline 3 is appropriate.

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

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

Description clearly specifies the tool performs 'read-only analysis of unconfirmed bank transactions' and lists specific analysis types (duplicates, invoice matches, own-account transfers, expense patterns), distinguishing it from sibling tools like reconcile_bank_transactions or classify_bank_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?

Description implies usage for analyzing unconfirmed transactions but does not explicitly guide when to use it versus alternatives such as classify_bank_transactions or reconcile_bank_transactions. No when-not or context exclusions 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?

The description discloses key behaviors beyond the annotations: a record holds only one document, an existing document is refused with document_exists unless replace_existing=true which overwrites it, and the RPS business rule. This adds valuable context about side effects and constraints that the annotations (destructiveHint=true) do not fully capture.

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

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

The description is two sentences with no fluff. It front-loads the core purpose and then provides essential behavioral details. Every clause earns its place, making it highly efficient for an agent to parse.

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

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

For a tool with 5 parameters and no output schema, the description covers the essential behavioral rules, the one-document constraint, the replace_existing option, and the business requirement. An agent has enough information to call the tool correctly in the right situations without needing additional clarification.

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. The description reiterates the replace_existing behavior and file types, but does not add significant new meaning beyond the schema. The RPS requirement is business context, not parameter-specific, so the description adds marginal value here.

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 (attach a source document), the resource types (purchase invoice, sale invoice, journal, bank transaction), and the accepted file formats (PDF/JPG/PNG). It distinguishes itself from sibling tools like get_document and delete_document by focusing on the attachment action, making its purpose unambiguous.

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

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

The description provides strong contextual guidance: it explains the one-document-per-record rule, the behavior when a document already exists, and the RPS requirement that source documents are mandatory for accounting entries. It does not explicitly state when not to use this tool or name alternatives, but the context is clear enough for an agent to decide when attachment is needed.

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

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

Beyond the annotations destructiveHint=true and idempotentHint=false, the description discloses per-success irreversibility, skipping of already-registered rows, and per-ID reporting of failures and indeterminate outcomes. These are exactly the behavioral details an agent needs before invoking a destructive batch tool.

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

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

The description is a single dense sentence with the core action front-loaded and each semicolon clause adding necessary behavioral information. It repeats no schema details and contains 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 destructive batch operation with no output schema, the description covers the key operational facts: irreversibility, skip behavior, and per-ID reporting. It could be slightly stronger by describing the response shape, but it is sufficient for correct invocation.

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

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

Schema description coverage is 100%, and both parameters already have meaningful descriptions: ids as positive integers with 1-500 entries, and reason as a required audit note up to 500 chars. The description adds no additional parameter-level meaning, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Confirm/register') and a specific resource ('multiple journals'), and the plural scope clearly distinguishes it from the singular sibling confirm_journal. It goes beyond the title by adding operational scope without ambiguity.

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

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

The phrase 'multiple journals' provides clear batch-use context and implicitly routes single-journal confirmations elsewhere. It does not explicitly name alternative tools or state when-not-to-use it, so it stops short of full explicit routing guidance.

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

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

The description goes beyond the destructiveHint annotation by explicitly stating 'IRREVERSIBLE', explaining that confirmed rows are skipped, and detailing how failures are reported per ID. This gives the agent a clear behavioral model of what happens during execution.

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

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

Two crisp sentences. The first delivers the core action and scope; the second adds essential behavioral warnings. No filler, and critical constraints (irreversibility) are 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?

Covers the essential operational details: irreversibility, skip behavior, and per-ID error reporting. Since there is no output schema, it would be stronger if it briefly described the success response format, but the given information is sufficient for a destructive batch operation.

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

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

Schema description coverage is 100%, with both 'ids' and 'reason' documented in the schema. The description adds no parameter-specific information, so the baseline of 3 is appropriate – the schema already carries the semantic load.

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: 'Delete multiple PROJECT transactions.' It clearly indicates batch operation and project scope, distinguishing it from the singular delete_transaction sibling. The purpose is unambiguous and immediately actionable.

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 batch usage via 'multiple' but provides no explicit guidance on when to prefer this over alternatives like delete_transaction or invalidate_transaction. It does not mention when not to use it or any conditions that would route the agent to a sibling 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 annotations declare destructiveHint=true, so the agent knows this is a mutation. The description adds valuable context beyond annotations by stating 'DRY RUN by default,' which is a critical safety behavior not covered by the annotations. It also correctly aligns with the destructive nature (creating journal entries). However, it does not disclose other behavioral details like idempotency or the need for a plan_handle for final execution, but those are partially covered by the schema. Given the annotations, the description adds solid behavioral value without 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 concise and front-loaded with the core purpose in the first sentence. The second sentence 'DRY RUN by default' is a key safety note placed prominently. There is no fluff or redundant information. While it is brief, it covers the main purpose and a critical behavioral default. It earns a high score for efficiency, though it could arguably be slightly more structured by separating purpose and default behavior.

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

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

Despite the 100% schema coverage, the description lacks critical process context. The tool involves a dry-run-then-commit flow (as indicated by the plan_handle parameter) but the description never mentions that users must first run a dry run to obtain an execution plan and then confirm with plan_handle for actual booking. This is essential for correct usage. Additionally, with no output schema, the description should hint at what the tool returns (e.g., an execution plan or result), but it does not. For a complex tool with 12 parameters and a two-step workflow, this description is 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?

The schema description coverage is 100%, so all parameters are documented in the schema. The description adds only a high-level overview and mentions 'withheld tax' and 'DRY RUN by default,' but these are also captured in the schema (e.g., tax_account param and dry_run param). It does not add deeper meaning about how parameters interrelate (e.g., which accounts apply to which row types) beyond the schema's own descriptions. Thus, it meets the baseline for full schema coverage but does not elevate beyond it.

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

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

The description clearly states the tool's purpose: create journal entries for Lightyear dividend, interest, and reward distributions, including withheld tax. It uses a specific verb ('create') and identifies the resource (journal entries) and the exact type of distributions. It distinguishes itself from siblings like 'book_lightyear_trades' and 'parse_lightyear_statement' by its focus on distributions, not trades or parsing. The mention of 'withheld tax' adds important scope detail.

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 distributions but does not explicitly state when to use this tool versus alternatives. It doesn't say 'use this for dividends, interest, and rewards, not for trade booking or capital gains.' There are sibling tools like 'book_lightyear_trades' and 'prepare_dividend_package' where a clear distinction would help. The description relies on the tool's name and purpose to convey usage context, but it lacks explicit exclusions or alternatives, leaving some inference to the agent.

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

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

Annotations indicate destructiveHint=true and readOnlyHint=false. The description adds behavioral context by stating 'DRY RUN by default' and the requirement for capital_gains_file on sells, which tempers the destructive nature. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose and default behavior. Every sentence provides essential information without redundancy.

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

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

Given the 14 parameters and no output schema, the description is brief and does not explain the overall workflow (e.g., dry run then confirm with plan_handle). While the schema details are thorough, the description could be more complete about prerequisites and process.

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

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

With 100% schema coverage, the input schema already describes each parameter. The description adds value by specifying that capital_gains_file is required for sells, which is not explicit in the schema property 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 verb 'Book' and the resource 'Lightyear stock Buy/Sell trades', distinguishing it from siblings like book_lightyear_distributions and parse_lightyear_statement.

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 key condition: for sells, capital_gains_file is required for FIFO cost basis and recognized gain/loss. It also notes the dry-run default. However, it does not explicitly differentiate when to use this tool versus similar tools like book_lightyear_distributions.

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 read-only, idempotent, non-destructive. The description adds behavioral context: it is a pure calculator, uses caller-supplied figures, does not read the ledger, and has date-gated rates. This goes beyond annotations by explaining what the tool does not do and its dependencies.

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

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

The description is concise (three sentences) and front-loaded with the primary function. Every sentence adds value: the first defines the computation, the second clarifies it is a calculator with dependencies, and the third states a negative behavior (does not read ledger). No unnecessary words.

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

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

Given the complexity (7 parameters, no output schema), the description covers the calculation logic, defaults, and dependencies. However, it does not describe the output format or structure, which would be helpful for an agent to interpret results. Still, the core behavior is well explained.

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

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

The description explains the calculation rules for representation and donation limits, adding meaning beyond the schema descriptions (e.g., 'Omit to skip the donation limit' and how months_elapsed defaults). Schema coverage is 100%, so the description complements rather than repeats, but it could detail parameter interactions more.

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

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

The description clearly states the tool computes TuMS §49 tax-free limits and the 22/78 income tax on excess, with specific formulas (representation 50€/month + 2% payroll; donations 3% payroll or 10% profit). It distinguishes itself from sibling tools by being a pure calculator that does not read the ledger, and references dependencies like compute_profit_and_loss.

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: it is a calculator over caller-supplied figures and does not read the ledger, so use when you have year-to-date data. It does not explicitly state when not to use or list alternatives, but the purpose is specific enough to avoid confusion with sibling tools.

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

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

Alias annotations declare readOnlyHint and idempotentHint, and the description adds behavioral context: it is a read-only advisory based on confirmed sale invoices, with detailed handling of various turnover types. No contradiction found.

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

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

The description is information-dense and well-structured, front-loading purpose and then detailing parameters. While slightly long, every sentence serves a purpose without wasted words.

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

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

Given the 8 parameters and no output schema, the description covers all necessary aspects: threshold value, date source, turnover classification, and operator choices. Missing only is explicit mention of the return value (e.g., boolean or threshold proximity).

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%, but the description significantly augments parameter meaning, e.g., clarifying that 'real_estate_turnover' only counts when not fixed-asset disposal, and 'manual_bucket_source' avoids double counting.

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 specifies the exact purpose: checking VAT registration threshold for Estonian companies with a clear threshold amount, date scope, and sourcing. It stands out distinctly from siblings by being a specialized advisory tool.

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

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

It provides clear context on when to use, explaining turnover types and operator judgment for incidental amounts. However, it does not explicitly mention alternatives or when not to use.

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

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

Annotations indicate destructiveHint=true, but the description only mentions 'requires approval' for execute_apply. It does not disclose what 'classify' does (e.g., is it read-only?), what 'dry_run_apply' previews, or the consequences of executing. The phrase 'Merged unmatched-bank classification' lacks behavioral context.

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

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

While very short (two sentences), the description is under-specified rather than concise. The first sentence is cryptic, and the second provides only mode names. It fails to earn its place by not adding value; a longer description would be warranted.

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 (6 parameters, three modes, destructive hint, no output schema), the description is grossly incomplete. It provides no information about return values, error conditions, or side effects. An agent cannot safely invoke this tool based solely on this description.

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

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

Schema coverage is 100%, so the schema already fully documents parameters. The description adds no additional meaning beyond the schema, meeting the baseline of 3.

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

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

The description opens with 'Merged unmatched-bank classification', which is vague and does not clearly state the tool's primary action. It then lists three modes without explaining what 'classification' means or how this tool differs from siblings like 'get_transaction' or 'suggest_booking'. The purpose is unclear and not differentiated.

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not explain when each mode is appropriate or what prerequisites exist (e.g., which accounts are eligible). An agent cannot determine the correct context for 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 indicate destructive behavior (destructiveHint=true), so the description does not need to reiterate that. It adds context about transferring metadata before deletion, which is good. However, it does not disclose irreversibility, required permissions, or potential side effects 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 a single sentence that efficiently conveys the two-step process. It is concise and front-loaded, but could be slightly improved by breaking into two sentences for readability. Overall, it earns its place without fluff.

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

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

Given the tool's simplicity, the description covers the key actions and constraints. It specifies the order of operations and the optional nature of metadata patching. However, it does not mention what the tool returns (e.g., success confirmation) or error scenarios, which 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 description coverage is 100%, so the baseline is 3. The description adds little extra meaning beyond the schema; it essentially restates the schema descriptions for the parameters. For 'patch_missing_fields', both description and schema mention 'fill only if the kept transaction still lacks those values', so no added 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 two-step action: apply missing CAMT metadata to the kept older transaction and delete the duplicate. It explicitly names the resources (CAMT metadata, older transaction, duplicate PROJECT transaction) and distinguishes from sibling tools like delete_transaction or detect_duplicate_purchase_invoice by focusing on the unique cleanup workflow.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It lacks explicit 'when to use' or 'when not to use' instructions, and there is no mention of prerequisites or conditions that would warrant cleanup.

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, idempotentHint, destructiveHint, so safety profile is clear. Description adds that it clears specific cached data (API and reference data), enhancing understanding beyond 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?

Two sentences, front-loaded with purpose. No redundant words. Every sentence adds value.

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

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

No output schema, but for a simple cache-clearing tool, the description sufficiently explains what it does and when to use. No missing information expected given its simplicity.

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

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

Input schema has 100% coverage, with description and enum for 'scope'. The tool description does not add extra parameter information beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool clears cached e-arveldaja API and reference data. It distinguishes itself from siblings as the only cache-clearing tool. The verb 'clear' plus resource 'cache' is specific.

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?

States explicit use cases: after changing data in web UI or before reports needing latest state. Provides clear context but no when-not-to-use or alternative tools mentioned.

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

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

Annotations already set destructiveHint:true. Description adds 'cannot be undone' which reinforces irreversibility. No additional behavioral context needed beyond the destructive nature and scope. 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?

Two sentences with no waste. First sentence states action and scope. Second sentence warns of destructiveness. Front-loaded and efficient.

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

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

For a tool with no parameters and no output schema, the description fully covers what the tool does (clear audit log), scope (current connection), and critical behavior (destructive, irreversible). No 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?

No parameters (0 params, schema coverage 100% vacuously). Description adds no parameter info because none exist. Baseline 4 for zero-param tools.

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

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

Description clearly states the action 'Clear the audit log' and specifies scope 'for the current connection'. Title reinforces the purpose. Distinct from siblings like get_session_log or list_audit_logs.

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?

Warns 'DESTRUCTIVE — cannot be undone' implying careful use, but does not explicitly state when to use or avoid, nor reference alternatives (e.g., use get_session_log to view first). Usage is implied but not fully guided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context (e.g., caching, performance implications, or what 'compute' entails beyond journal postings). With annotations present, the description is adequate but not value-adding.

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

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

The description is a single, concise sentence that effectively communicates the core purpose. Every word earns its place, with no fluff or redundancy.

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

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

Given the absence of an output schema, the description should clarify what the tool returns (e.g., a single balance figure, a structured object). It fails to provide this crucial context, leaving the agent uncertain about the response format. For a computation tool, this is a notable 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 coverage is 100%, so all parameters are well-described in the schema. The description only reiterates the optional client/date filters, adding no new semantic context beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Compute') and resource ('account balance') with scope ('from journal postings with optional client/date filters'). It clearly distinguishes from sibling tools like compute_payables_aging and compute_account_dimension_balances.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It only states optional filters, but lacks context about prerequisites or exclusions. With many sibling compute tools, this omission is significant.

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

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

Annotations already indicate the tool is read-only, idempotent, and not destructive. The description adds behavioral details about including opening balances and outputting one row per dimension plus a total, which goes beyond what annotations provide.

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

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

Two sentences that are concise and front-loaded with the main action. Every sentence adds useful information without extraneous 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?

The tool has moderate complexity (4 params, no output schema) but strong annotations. The description explains the output structure and relation to sibling. It lacks edge-case or error-handling info, but for a read-only compute tool this is sufficient.

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

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

Schema coverage is 100% with descriptions for all parameters. The description does not add parameter-specific details beyond the schema, but it provides context about the tool's operation (e.g., breakdown, total). 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's purpose: breaking down an account's balance per dimension with examples (e.g., bank sub-accounts). It distinguishes itself from the sibling tool 'compute_account_balance' by noting that the total row equals that tool's output.

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

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

The description implies when to use this tool (for a dimensional breakdown) versus the sibling for a total. It provides context on the output including opening balances, but does not explicitly state when not to use it or list alternatives beyond the one sibling.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds valuable context about how accounts are grouped (Varad vs Kohustused+Omakapital), which is beyond 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?

Two sentences, no fluff, immediately states purpose and grouping. Efficient and front-loaded.

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

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

The tool has only two parameters and no nested objects. However, without an output schema, the description should ideally explain the return value (e.g., a balance sheet report). The grouping info helps but lacks output format details.

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

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

Schema coverage is 100% and both parameters ('fresh' and 'date_to') are well-described in the schema. The description does not add new information beyond the schema, so baseline 3 applies.

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

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

The description clearly states the tool computes a balance sheet from journal postings and specifies the grouping into Assets and Liabilities+Equity. This distinguishes it from sibling tools like compute_trial_balance and compute_profit_and_loss.

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 generating balance sheets but does not provide explicit when-to-use or when-not-to-use guidance compared to alternatives like compute_trial_balance or compute_profit_and_loss. Usage context is only implied.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds no additional behavioral context (e.g., caching, rate limits, or side effects). Parameter 'fresh' is described in the schema but not in the tool description itself.

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?

Single sentence, clear and direct. No unnecessary words or redundancy. Efficiently communicates the tool's core function.

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

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

With no output schema, the description omits return value details. The phrase 'across selected accounts' is clarified by the parameter schema but the output structure is unspecified. Adequate for a simple compute tool but incomplete for agent understanding.

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

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

Schema description coverage is 100%, and the description adds no parameter-specific meaning. Baseline 3 is appropriate; the description does not enhance understanding 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?

Description clearly states the tool computes net position for a client across selected accounts. Verb 'compute' and resource 'net position' are specific. Distinguishes from sibling tools like compute_account_balance or compute_payables_aging, though the term 'net position' could be more precisely defined.

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 alternatives. No mention of prerequisites, exclusions, or typical use cases. The description merely states what it does without contextualizing its optimal usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat safety traits. The description adds the behavioral detail that the computation is from unpaid purchase invoices, but no additional traits beyond what annotations provide. It is consistent 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 a single sentence that is clear and to the point. It could potentially be expanded slightly for structure, but it is already concise and front-loaded with the core purpose.

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

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

Given there is no output schema, the description should indicate what the tool returns (e.g., aging buckets, totals by period) to help the agent understand the result. The description only explains the input and data source, leaving the output format entirely unspecified, which is a significant gap for a compute tool.

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

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

Schema description coverage is 100% for the single parameter as_of_date, which already explains its format and default. The description adds the phrase 'for a specific cutoff,' which marginally reinforces the schema but does not provide new semantic meaning beyond what the schema already conveys.

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 computes payables aging by supplier from unpaid purchase invoices, distinguishing it from sibling tools like compute_receivables_aging which handles receivables. The verb 'compute' and resource 'payables aging' are 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 mentions passing as_of_date for a specific cutoff, which gives some usage context, but it does not explicitly state when to use this tool versus alternatives like compute_receivables_aging or provide any when-not scenarios. Usage is inferred from the purpose rather than explicitly guided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral detail beyond annotations: it states that account 9000 and legacy YECL closing journals are excluded, and defines the calculation as revenue minus expenses. This helps the agent understand what data affects the result.

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

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

Two short, information-dense sentences. The core purpose is front-loaded, and the exclusion detail is a single dependent clause. No redundant words or restatements.

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

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

For a read-only report tool with three documented parameters and no output schema, the description covers the essential semantics: what is computed, what is excluded, and the period requirement. The 'fresh' parameter behavior is documented in the schema. It does not describe return format, but that is not required given the output schema is absent and the tool's simplicity.

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

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

Schema coverage is 100% – all three parameters (date_from, date_to, fresh) have descriptions in the input schema. The description only adds the contextual phrase 'for a period' and does not add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Compute') and resource ('profit and loss statement') and defines its scope as 'revenue minus expenses'. Including the Estonian term (kasumiaruanne) and the exclusion of specific accounts distinguishes it from sibling tools like compute_balance_sheet and compute_trial_balance.

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 a period-based P&L but does not explicitly say when to choose this over compute_balance_sheet or compute_trial_balance, nor does it mention conditions or alternatives. Context is clear enough for an agent, but no explicit guidance is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds no extra behavioral details beyond stating it computes from unpaid sale invoices, which is already obvious.

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

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

The description is two sentences: first states purpose, second provides parameter guidance. No redundant words, front-loaded with core action, very 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?

The tool is simple (1 param, no output schema), but the description does not explain what the computed report contains or its format. Given the absence of an output schema, some expectation of the return value 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% (the only parameter is described in the schema). The description adds the notion of 'specific cutoff' but does not provide additional semantic meaning beyond what the schema's description already offers. 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 ('Compute'), the resource ('receivables aging'), and the scope ('by client from unpaid sale invoices'). It is distinct from the sibling tool 'compute_payables_aging' which handles payables, not receivables.

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 usage guidance for the parameter ('Pass as_of_date for a specific cutoff') but does not explicitly contrast with sibling tools or state when not to use this tool. Usage context is implied but not directly addressed.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: without date_to, all postings including future-dated ones are included, with period.to treated as unbounded. This is a meaningful edge case an agent needs to know.

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

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

Two sentences, each earning its place: the first states what the tool computes and shows, the second flags the critical date_to behavior. Information is front-loaded and there is no fluff.

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

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

With annotations covering the safety profile and the schema documenting all three parameters, the description fills the remaining gaps: what the report contains and how a missing date_to behaves. No output schema exists, but the description gives enough about the return concept for an agent to reason about the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by explaining the consequence of omitting date_to (future-dated postings are counted), which gives real semantic weight to the parameter. It does not add detail about date_from or fresh beyond what the schema already says.

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 ('Compute trial balance') and clarifies the exact output: debit/credit totals and balance for each account. It also anchors the data source ('from journal postings'), which helps distinguish it from report siblings like compute_balance_sheet or compute_profit_and_loss.

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

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

Usage context is implied by the tool name and the phrase 'from journal postings', but no explicit guidance is given about when to choose this over alternatives such as compute_account_balance or compute_balance_sheet. The description does not name sibling tools or state exclusions.

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

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

Annotations already mark destructiveHint=true, but description adds 'IRREVERSIBLE' and mentions reversal method, providing valuable 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?

Two concise sentences, front-loaded with action and key behavioral trait. No wasted words.

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

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

For a simple tool with one parameter and no output schema, description covers purpose, irreversibility, and alternative action, making it complete and actionable.

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 parameter 'id' is fully described in schema. Description adds no additional parameter-level detail 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?

Description uses specific verb 'Confirm/register' and clearly identifies resource 'journal entry'. It distinguishes itself by noting irreversibility and suggesting the sibling tool 'invalidate_journal' for reversal.

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

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

Explicitly states the action is irreversible and advises using 'invalidate_journal' to reverse, providing clear when-to-use guidance. Could be more explicit about prerequisites but sufficient.

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

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

Annotations already signal destructive/read-write behavior (destructiveHint=true, readOnlyHint=false); the description adds that the action locks the invoice and does not change approved totals. It does not disclose irreversibility details or the role of the approved_correction object, but the 'lock' language and correction constraint add useful context beyond the annotations.

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

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

Two short sentences, no filler, and the core locking behavior is front-loaded. The statement earns its place and remains easy to parse.

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

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

Given the destructive annotation, nested object parameter, and absence of an output schema, the description is too sparse to support correct invocation: an agent cannot determine how to populate approved_correction, what recalculate_totals does, or what response to expect. It is adequate only as a high-level summary, not as a complete call specification.

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 only 33%: only id has a description ('Object ID'), while recalculate_totals and approved_correction are undocumented. The description hints at the approved-preview flow for corrections but never maps that to the approved_correction parameter or explains recalculate_totals, so it fails to compensate for the low schema coverage.

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

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

The description uses a specific verb ('Confirm and lock') and resource ('purchase invoice'), and clarifies that approved totals are preserved. The second sentence differentiates it from a totals-correction flow, so an agent can distinguish it from invalidate_purchase_invoice and preview_purchase_invoice_totals_correction.

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

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

It sets clear context: confirmation is a locking action, and any totals correction must go through a fresh approved preview first, which points to preview_purchase_invoice_totals_correction. It doesn't explicitly name alternatives or state when invalidation is preferred, but the key exclusion for correction is present.

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 'Locks the invoice for editing' and 'Reversible via invalidate_sale_invoice', complementing annotations (destructiveHint=true). No contradictory info. Could mention state changes or requirements, but overall clear.

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

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

Two concise sentences with front-loaded action. Every word adds value, 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?

Lacks output schema, so return value not described. No mention of required state or permissions. But given parameter simplicity and annotations, it is minimally adequate.

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?

Single parameter 'id' with schema description 'Object ID'. Description adds no extra meaning beyond schema, which already has 100% coverage. 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?

Clearly states verb 'Confirm' and resource 'sales invoice'. Additional detail 'Locks the invoice for editing' specifies effect. Distinguishes from sibling tools like 'invalidate_sale_invoice' and 'create_sale_invoice'.

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

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

Provides when to use (confirm an invoice, lock editing) and explicit reference to reversal via 'invalidate_sale_invoice'. Lacks explicit prerequisites or when-not-to-use, but context is sufficient.

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

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

Annotations already declare destructiveHint=true, so the mutating nature is known. The description adds valuable behavioral context beyond that: rejection with 'buyer or supplier is missing', refusal on client mismatch, auto-resolution from invoices, the reassign approval path, and the post-confirm re-read of the journal. It does not spell out what exactly is destroyed or changed, but the annotation covers the destructive profile and the description adds meaningful edge-case behavior.

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

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

The description is longer than typical, but every sentence carries essential behavior: the core action, conditional client handling, mismatch refusal logic, and post-confirm verification. It is front-loaded with the main purpose and then progressively details exceptions. Slightly dense but not redundant or padded.

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, destructive confirmation tool with no output schema, the description covers most operational edge cases: CAMT imports, invoice distributions, client mismatches, duplicate handling, and journal re-checking. It does not explicitly describe the return value or success/failure payload, which is a notable gap given there is no output schema, but the failure conditions and side effects are well documented.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real value by explaining the business context behind the parameters: why clients_id is required for CAMT imports, how invoice-linked distributions auto-resolve the client, and when block_on_duplicate and reassign_client_to_invoice should be used. It goes beyond restating the schema and clarifies parameter interplay in realistic scenarios.

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

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

The description opens with a specific verb and resource: 'Confirm a bank transaction by providing distribution rows.' It clearly distinguishes this from sibling confirm tools (confirm_journal, confirm_sale_invoice) by specifying the bank-transaction context and the distribution-row mechanism. The additional details about CAMT imports and invoice-linked confirms further anchor its scope.

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

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

Provides explicit conditional guidance: when to pass clients_id (no clients_id, CAMT imports, non-invoice distributions), when clients_id is auto-resolved (invoice distributions), and when to use reassign_client_to_invoice (third-party payer mismatch). It does not explicitly name alternative tools for when not to use this one, but the context strongly implies the appropriate use cases, so the guidance is clear though not fully comparative.

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 idempotentHint=true and readOnlyHint=false, covering retry-safety and mutation potential, so the risk burden is lower. The description itself adds no behavioral context, but the schema's parameter notes supply important traits such as 'consume-once plan handle' and 'never approval or mutation authority', leaving the overall definition non-misleading.

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

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

The description is a single tight sentence with no filler, repetition, or unnecessary words. It is concise and front-loaded with the primary continuation capability, though it omits the execute action, which slightly reduces completeness for a complex tool.

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

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

For an 8-parameter, 4-action tool with no output schema, the description alone is not sufficient: it leaves out execute_review_action and does not explain how actions relate to parameters. The input schema and annotations fill most of the gaps, making the full definition workable, but the description does not stand alone.

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, and the tool description adds no parameter-level meaning. The schema descriptions are detailed about which actions read which parameters, so there is no semantic gap, but the description field provides no additional value here.

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 three distinguishable operations: continue a workflow, resolve a review item, and prepare an approval action, using explicit verbs and resources that go beyond the title. However, the phrasing 'continue an accounting workflow response' is awkward, and the description omits the 'execute_review_action' capability that is present in the schema, so it does not fully map to the action enum.

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 siblings such as recommend_workflow, accounting_inbox, or save_auto_booking_rule, and it offers no exclusions or prerequisites. The schema's action descriptions imply usage per action, but the tool description itself does not help an agent decide between this and alternative tools.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds no behavioral context such as whether the operation is reversible, requires specific permissions, or triggers side effects like notifications or recalculations.

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 short but ineffective. It merely restates the tool's name, wasting the opportunity to convey meaningful information. True conciseness balances brevity with informativeness.

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 5 parameters (2 required), no output schema, and many siblings, the description fails to explain return values, scope of creation, or any constraints. It leaves the agent guessing about the tool's overall behavior.

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

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

Schema coverage is 100% with descriptions for all 5 parameters, so the description does not need to add parameter details. It neither contradicts nor supplements the schema, meeting the baseline but adding no extra 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 'Create a bank account' is a tautology of the name and title. It provides no additional detail about what creating entails, such as what fields or constraints apply, and does not distinguish it from sibling tools like get_bank_account, update_bank_account, or delete_bank_account.

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 like update_bank_account or list_bank_accounts. There is no mention of prerequisites, required data, or context for 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 signal a non-read-only mutation, so the description adds no behavioral information beyond 'create'. It does not disclose that creation can be refused due to duplicate registry codes, that is_physical_entity is mandatory, or that foreign legal entities require explicit attestation. Those details exist in parameter descriptions, not in the tool description.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to identifying the action and the 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?

Despite being a 14-parameter tool with validation rules and no output schema, the description only states the basic action. It does not explain what the tool returns, how duplicates are handled, or which fields are required for different entity types. The rich schema helps, but the description alone is not contextually complete for safe invocation.

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

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

Schema description coverage is 100%, so all parameter meanings are already documented. The description's '(buyer/supplier)' framing adds slight context for understanding is_client and is_supplier, but it does not add meaningful information beyond what the schema already provides.

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

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

The description uses a specific verb and resource: 'Create a new client (buyer/supplier)'. It clearly distinguishes this tool from siblings like update_client, get_client, list_clients, deactivate_client, and delete_client by naming the creation action.

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 creating a new client but gives no explicit guidance on when to prefer it over alternatives or what prerequisites/checks should come first. It also does not mention that update_client or duplicate-checking tools may be relevant when handling existing records.

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 destructiveHint=false, implying a mutation that is not destructive. The description adds no behavioral details, such as permissions, side effects, or required prior steps.

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 brief (four words) and nearly tautological with the title. It lacks substance and does not justify its length.

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 6 parameters (5 required) and no output schema, the description fails to explain what an invoice series is, how it is used, or what the tool accomplishes beyond the name.

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%, so parameters are described well. The tool description adds no extra meaning beyond the schema, which is acceptable but does not leverage the description to clarify parameter relationships or defaults.

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 'Create an invoice series' clearly communicates the verb and resource. However, it does not differentiate from sibling tools like update_invoice_series or delete_invoice_series, leaving ambiguity about the specific 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 guidance is provided on when to use this tool versus alternatives, nor are there any prerequisites or contextual clues about when 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 it is a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds 'Create' but does not disclose additional behavioral traits such as idempotency, side effects, or authorization needs. It is adequate but does not exceed annotation coverage.

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

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

The description is a single, front-loaded sentence with no fluff. It is concise but could benefit from slightly more context without becoming verbose. Very 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?

Despite full schema coverage, the description is too brief for a complex accounting tool. It does not explain journal entry concepts, posting behavior, or return values (no output schema). The agent may lack key context for correct invocation.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description adds minimal extra meaning ('Create a journal entry with postings') but does not compensate beyond what the schema provides. 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 'Create a journal entry with postings' clearly states the action (create) and the resource (journal entry with postings). It distinguishes itself from sibling tools like 'get_journal' or 'update_transaction', though it could be more specific about the accounting context.

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 alternatives like 'update_transaction' or 'confirm_journal'. The description does not mention prerequisites, scenarios, or exclusions, leaving the agent to infer usage from 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 provide no hints (all false), but the description does not compensate. It omits behavioral traits like idempotency, side effects, or required permissions. Simply stating 'Create a journal' is insufficient for a complex write operation.

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

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

Very concise single sentence. It is front-loaded with the key purpose. However, given the tool's complexity (12 parameters), slightly more detail would not harm 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?

Given 12 parameters and no output schema, the description is too minimal. It does not explain what the resulting journal looks like, which accounts are affected, or the typical workflow context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no parameter-level information 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?

Description clearly states the specific action ('Create a journal') and resource ('business expense paid personally by the owner'). It distinguishes from generic journal creation tools like create_journal.

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 such as create_journal or other expense-related tools. The description lacks context for selection.

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

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

Description only states the action, adding no behavioral context beyond annotations. No mention of side effects, constraints, or error conditions.

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?

Single sentence with no waste. Concise but could benefit from more detail without being verbose.

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

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

Given the complexity (11 parameters, many optional), the description is too minimal. No mention of return value, uniqueness constraints, or parameter interdependencies.

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. Description adds no additional parameter meaning or relationships 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?

Description clearly states the tool creates a new product/service. Verb and resource are specific, and while siblings include other entity operations, the resource type distinguishes it adequately.

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 alternatives (e.g., update_product, deactivate_product). Lacks context on prerequisites or scenarios.

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 reveals behaviors beyond annotations: it states that vat_price and gross_price are required because confirm_purchase_invoice fails without them, and that base_* values may lock actual EUR settlement. Annotations show readOnlyHint=false and destructiveHint=false, which are consistent with creating a draft.

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, two sentences, front-loaded with the main purpose. It packs important guidelines efficiently, though the dense format may require careful parsing.

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 (18 parameters, no output schema), the description covers the main contract conditions and dependencies. However, it does not explain the overall process (create draft then confirm) or what the return value is, leaving some context 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?

With 100% schema coverage, the description adds extra meaning: e.g., 'Required — confirm_purchase_invoice fails without it' for vat_price/gross_price, and 'auto-derived from currency_rate when omitted' for base_* fields. This goes beyond the schema's parameter 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 'Create a draft purchase invoice' and provides specific details about the direct-call contract, differentiating it from sibling tools like create_purchase_invoice_from_pdf (which creates from PDF) and confirm_purchase_invoice (which confirms).

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 explicit conditions: 'pass exact invoice vat_price/gross_price' and 'non-EUR requires cl_currencies_id + currency_rate'. It implies when to use this tool but does not explicitly mention alternatives like create_purchase_invoice_from_pdf for when PDF is available.

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 show a non-read-only, non-destructive mutation, and the description adds real behavioral detail: it creates a draft, attaches the source, forbids recalculation, and notes that base_* may lock EUR settlement. It does not mention duplicate-warning/refusal behavior, but that is not a contradiction and schema covers it.

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

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

Two sentences pack the core purpose plus the most safety-critical call rules with no filler. The primary action is front-loaded, and the dense second sentence is all high-value guidance.

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 22-parameter creation tool, the description plus full schema coverage is nearly complete: it identifies the extraction pipeline, exact-total rules, currency handling, and EUR-base locking. It does not describe the return value or post-creation confirmation step, which would matter since there is no output schema, but this is a minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3; the description's 'contract' adds interconnected call semantics beyond the individual fields, especially that base_* values can lock the settled EUR amount rather than just being derived. Most parameter meaning still comes from the schema, which is appropriate.

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

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

The description names a specific verb and resource ('Create a draft purchase invoice') plus the distinctive source ('from extracted document data') and side effect ('attach the source file'). It reads as distinct from sibling create_purchase_invoice by tying itself to an extraction pipeline.

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?

'From extracted document data' and 'Direct-call contract' establish the intended post-extraction, careful-call context, and the rule to pass exact totals. However, it never explicitly contrasts this with create_purchase_invoice or states when not to use this variant, so the guidance relies on 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?

The description discloses key behaviors: cloning creates draft invoices, auto-assigns invoice numbers, and dry_run previews without creation. This adds value beyond the annotations (which mark destructiveHint=true) by clarifying the preview mode and auto-assignment.

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

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

The description is extremely concise—two sentences, 15 words—with no unnecessary information. Every sentence conveys essential information, making it efficient for an AI agent to parse.

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

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

Without an output schema, the description does not explain return values or error handling. It covers the core operation but omits details about what the response contains (e.g., list of IDs) and potential failure scenarios, leaving some 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%, so parameters are already well-documented. The description adds minimal additional meaning beyond the schema, only reinforcing the dry_run behavior and mentioning auto-assigned invoice numbers (not a parameter). Thus 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 action ('clone'), the resource ('previous-month sale invoices'), and the result ('DRAFT recurring invoices'). It distinguishes this from other invoice tools by explicitly mentioning recurring invoicing and the cloning mechanism.

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 using dry_run=true for previewing, which gives some usage guidance. However, it does not explicitly state when to use this tool versus alternatives like create_sale_invoice, nor does it provide 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 indicate this is a non-readonly, non-destructive creation action. The description adds no further behavioral details, such as whether the invoice is created as draft or confirmed, or any side effects.

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

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

The description is very concise with one short sentence, which is front-loaded but underspecified for a tool with 12 parameters. It earns its place but is too brief.

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

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

Given the complexity (12 parameters, 6 required, no output schema), the description is extremely incomplete. It fails to mention return value, prerequisites, or potential errors, making it inadequate for effective tool selection.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add extra meaning beyond what the parameter descriptions already provide.

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

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

The description clearly states 'Create a sales invoice', specifying the verb and resource. It distinguishes from sibling tools like create_purchase_invoice and confirm_sale_invoice.

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

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

No guidance is provided on when to use this tool versus alternatives such as create_recurring_sale_invoices or confirm_sale_invoice. The description lacks any context about appropriate usage scenarios.

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 does not add behavioral context beyond what annotations already provide (readOnlyHint=false indicates a write operation). It omits details like side effects, required permissions, or whether duplicate detection is enabled (though mentioned in parameter description).

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

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

The description is a single sentence with no wasted words. It is front-loaded and concise, but could be slightly expanded to improve clarity without sacrificing 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?

Given the tool's complexity (10 parameters, required fields, enums) and the absence of an output schema, the description is too minimal. It does not explain the overall function or common use cases, leaving the agent to infer from parameter names alone.

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

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

Schema coverage is 100%, so the baseline is 3. The tool description does not add meaning beyond the property descriptions in the schema, failing to highlight key parameters like 'type' or 'block_on_duplicate' that have critical 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 the verb 'create' and the resource 'bank transaction', making the basic purpose understandable. However, it does not differentiate this from sibling tools like 'create_sale_invoice' or 'create_purchase_invoice' which also create financial records.

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

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

No guidance is provided on when to use this tool versus alternatives, such as 'create_sale_invoice' for invoices or 'update_transaction' for modifications. There are no prerequisites or contextual hints.

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-destructive (destructiveHint=false) and idempotent (idempotentHint=true). The description adds the reversibility detail, but does not significantly extend beyond what annotations convey.

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

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

Single sentence, concise and to the point, with no 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?

Given the simple tool with one parameter and no output schema, the description adequately covers the action and its reversibility, making it complete for 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?

Schema coverage is 100% with a clear description for the only parameter 'id'. The tool description adds no further parameter clarification, so baseline score applies.

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

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

Description clearly states 'Deactivate a client' as the action, with the specific verb and resource. It mentions reversibility via 'reactivate_client', distinguishing it from permanent deletion (delete_client) or other client operations.

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

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

Provides context that the client can be restored with reactivate_client, implying when to use this tool over deleting. However, it does not explicitly state when not to use or compare to alternative tools like update_client.

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 idempotent and non-destructive behavior. Description adds that it can be restored, but doesn't elaborate on side effects or state changes, so it's adequate but not enhanced.

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?

Exceptionally concise: one sentence that conveys the core action and a key behavioral trait (reversibility). No redundancy or filler.

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

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

For a simple boolean-state change tool with one parameter and no output schema, the description covers purpose and reversibility. Lacks details on the post-deactivation state, but overall sufficient.

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

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

Schema covers 100% of the single parameter ('id' as 'Object ID'). Description adds no extra semantic meaning beyond the schema, so baseline 3 is appropriate.

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

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

Clearly states the action (deactivate) and resource (product). Mentions reversibility via reactivate_product, distinguishing it from delete_product.

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 like delete_product or reactivate_product. Only mentions it can be restored, but doesn't explain use cases 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 mark destructiveHint=true, so the description's destructive nature is redundant. However, the description adds valuable behavior: 'Fails if the account is referenced by existing transactions', which goes beyond annotations and informs the agent of a critical constraint.

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

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

The description is a single sentence with a conditional clause, no wasted words. It immediately communicates the core action, followed by the key behavioral constraint. Perfectly sized for the tool's simplicity.

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

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

For a simple delete tool with one parameter and no output schema, the description covers the action and a critical failure condition. It does not mention the return value or irreversibility (implied by annotations), but is largely sufficient given the tool's low 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% for the single parameter 'id', with a clear description 'Bank account ID'. The tool description adds no further parameter details, so it does not improve upon the schema's semantic clarity.

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 'Delete a company bank account', identifying the tool as a destructive operation on a specific resource. The additional condition 'Fails if the account is referenced by existing transactions' sets it apart from sibling tools like delete_client or delete_product, providing unique context.

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

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

The description implies use when permanent removal is desired, but does not explicitly compare to alternatives like deactivation (though no sibling deactivate exists). It provides a condition but lacks guidance on when not to use the tool or prerequisites beyond the failure case.

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

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

Annotations already indicate destructiveHint=true. Description adds context: failure when referenced and intended use case. Does not contradict annotations and extends understanding of behavior.

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

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

Two sentences, no unnecessary words. Every sentence provides value: first states action and behavior, second gives usage direction. Highly 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 simple delete operation with clear annotations and schema, the description covers purpose, failure conditions, alternatives, and intended usage. No output schema, but not needed for this operation.

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

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

Only one parameter 'id' with schema description 'Object ID' and constraints. Schema coverage is 100%, and the description adds no extra parameter meaning beyond what the schema provides, so baseline 3.

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

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

Description clearly states 'Permanently delete a client' and distinguishes from sibling 'deactivate_client' by noting deletion fails if referenced. It specifies the verb and resource, and differentiates from alternative actions.

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

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

Explicitly provides when to use (for mistakenly-created master data with no history) and when not to use (if referenced, use deactivate_client). The failure condition is stated, giving clear 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 destructiveHint=true, so the description correctly aligns by stating 'Delete'. However, the description does not add additional behavioral context such as irreversibility, permissions, or fallback behavior if no document exists. With annotations present, the description meets minimal expectations.

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

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

The description is a single, front-loaded sentence containing only essential information. Every word serves a purpose, and there is no redundancy or fluff.

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

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

For a simple delete operation with no output schema, the description adequately covers the what and which. It could mention what happens if no document exists, but given the tool's simplicity, it is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description's mention of 'attached to a purchase invoice...' loosely mirrors the enum values in entity_type, adding no new semantic details beyond the schema.

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

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

The description clearly states the verb 'Delete' and the resource 'source document', specifying the exact record types it applies to (purchase invoice, sale invoice, journal, bank transaction). This distinguishes it from sibling tools that delete entire records (e.g., delete_sale_invoice).

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

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

The description implies the tool is used to remove a source document from specific record types, but it does not explicitly state when to use it versus alternatives, nor does it mention prerequisites, error conditions, or when not to use it.

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

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

Annotations already indicate destructiveHint=true, so the description adds value by specifying the failure condition when the series is in use. This provides behavioral context beyond the annotation.

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

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

The description is a single, complete sentence with no redundant words. It is front-loaded and efficient.

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

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

For a simple delete tool with one parameter and no output schema, the description adequately covers purpose and a key failure condition. It could mention success behavior or irreversibility, but overall it is sufficient.

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

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

The schema covers 100% of parameters with a clear description for 'id'. The tool description does not add additional meaning to the parameter, but the schema is sufficient. 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 the action 'Delete' and the resource 'invoice numbering series', making it distinct from sibling tools like create or update. It leaves no ambiguity.

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

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

The description mentions a failure condition ('Fails if the series is already in use') but does not explicitly guide when to use this tool versus alternatives like update or create. Usage context is implied rather than explicit.

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

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

While annotations already mark the tool as destructive (destructiveHint: true), the description adds no further behavioral context. It does not explain whether deletion is permanent, if it cascades, or if any confirmation is needed. The description adds no value beyond the annotation.

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 with one sentence and no wasted words. However, it is so minimal that it misses opportunities to provide helpful context. It earns its place for brevity but lacks substance.

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 destructive nature of the tool (from annotations) and the absence of an output schema, the description fails to explain the implications of deletion, any prerequisites, or the result. It is incomplete for a mutation tool of this significance.

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

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

The input schema covers the single parameter 'id' with a description ('Object ID') and constraints. Since schema coverage is 100%, the baseline is 3. The description adds no additional parameter-specific details or examples, 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 the action ('Delete') and the resource ('a journal entry'). It is specific and matches the tool name. However, it does not differentiate from the sibling tool 'invalidate_journal' which might have a similar 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 offers no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or contexts where the tool is appropriate. This leaves the agent without decision-making support.

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

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

Annotations already indicate destructiveHint=true. The description adds useful context: tool fails if the product is referenced by invoices, and that the deletion is permanent. No contradiction with annotations.

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

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

Two sentences with zero waste. The description is front-loaded with the core action and immediately provides key constraints.

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 single parameter, no output schema, and annotations covering destructiveness, the description is complete. It explains the failure condition and alternative usage.

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 parameter is well-defined. The description does not add meaning beyond the schema for the 'id' parameter. 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 'Permanently delete a product/service' with a specific verb and resource. It also distinguishes from the sibling tool deactivate_product by explaining when to use the alternative.

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

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

The description explicitly states when to use (mistakenly-created master data with no history) and when not to (if referenced by invoices, use deactivate_product). Provides a clear alternative.

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

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

Annotations indicate destructiveHint=true, so the description doesn't need to repeat that. However, it adds no additional behavioral context such as permanence, required permissions, or effects on related data. The description is neutral.

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?

Extremely concise at six words, with no unnecessary information. The purpose is front-loaded and immediately clear.

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

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

For a simple delete operation with one parameter and annotations covering destructiveness, the description is adequate but incomplete. It lacks context about prerequisites (e.g., invoice state) and what the return value indicates.

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 'id' parameter. The description adds no extra meaning beyond the schema, so baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Delete' and the resource 'purchase invoice', making the tool's function unambiguous. It distinguishes from sibling tools like 'invalidate_purchase_invoice' by using specific terminology.

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 (e.g., invalidate) or any prerequisites (e.g., invoice must be unconfirmed). The description only states the action without 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 annotations already declare destructiveHint: true, indicating the operation is destructive. The description adds no further behavioral context (e.g., irreversibility, required permissions, what gets deleted). It neither contradicts nor enriches 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 a single, concise sentence with no wasted words. It could benefit from slightly more detail without losing efficiency, but it is appropriately front-loaded.

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

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

Given the tool's simplicity (one required param, destructiveHint annotation, no output schema), the description is minimally adequate. However, it lacks context about when deletion is appropriate or what the expected outcome is, leaving some ambiguity for an AI 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 description coverage is 100% for the single parameter 'id', which is described as 'Object ID' in the schema. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action 'Delete' and the resource 'a sales invoice', providing a specific verb-resource pair. However, it does not differentiate from sibling delete tools (e.g., delete_bank_account, delete_client), leaving the agent to infer context from the tool name alone.

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

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

The description gives no guidance on when to use this tool versus alternatives like invalidate_sale_invoice or other deletion tools. There is no mention of prerequisites, side effects, or context for use.

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

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

Annotations already indicate destructiveHint=true, so the agent knows it's destructive. The description adds no additional context (e.g., irreversibility, permissions, cascading effects). Minimal 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 very concise (one short sentence). It is front-loaded but lacks sufficient detail, making it minimally adequate.

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 action with no output schema, the description should include consequences, return values, or usage notes. It is incomplete for safe and informed use.

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 a generic 'Object ID'. The tool description does not clarify that 'id' refers to a transaction ID. Baseline 3 is appropriate since schema covers 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 'Delete a transaction' clearly states the verb and resource. It indicates single-transaction deletion but does not distinguish from sibling 'batch_delete_transactions' or 'invalidate_transaction'.

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 alternatives like 'invalidate_transaction' or 'batch_delete_transactions'. 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only the matching criteria and does not disclose output format, ordering, or duplicate-result semantics, which are not covered by annotations due to no output schema.

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

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

One tight sentence with a front-loaded verb and resource plus the four matching criteria. No filler or repeated annotation 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 no output schema, an agent cannot tell whether the tool returns a boolean, a list of duplicate candidates, or a match count; that is a meaningful gap for a detection tool. The parameter meanings and safety profile are well covered by the schema and annotations, so the tool is callable but not fully self-explanatory.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's high-level mention of supplier, invoice number, amount, and date maps to the parameters, but it adds little over the schema descriptions, which already explain matching behavior such as ±7 days for amount matching.

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

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

The description names a specific action ('Check duplicate purchase invoices') and lists the matching dimensions (supplier, invoice number, amount, date), so an agent can tell what the tool does. It is clear, though it does not explicitly contrast itself with sibling invoice tools such as validate_invoice_data or cleanup_camt_possible_duplicate.

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

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

The intended use is implied: call this when an incoming purchase invoice needs to be checked against existing invoices for duplicates. However, the description gives no explicit when-to-use/when-not-to-use guidance and does not name alternative tools for similar invoice-validation work.

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 claims 'never books an existing entry twice', which is an idempotency guarantee, but the annotations set idempotentHint=false. This directly contradicts the structured metadata and could mislead an agent about retry safety. The other behavioral details (draft journals, confirm requirement) are useful, but the contradiction forces a score of 1.

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