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

With no annotations provided, the description carries the full burden. It does disclose a key behavioral consequence: binding the session actor to the invited identity and activating membership, which implies a state change and identity mutation. However, it doesn't mention whether this is irreversible, whether the token is consumed, what errors occur on invalid/expired tokens, or whether this affects the current session permanently. Some gaps remain but the core side effect is disclosed.

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

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

Two sentences with no filler. The core action and effect are front-loaded, and the contextual note about pre-workspace is succinctly placed. 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?

For a tool with one required parameter and no output schema, the description is nearly complete. It explains what happens, when it happens (pre-workspace), and the binding effect. It could be more complete on error cases or token lifecycle, but those are secondary for basic invocation. The context note about the accepter not being a member yet is useful and somewhat unusual. It's slightly incomplete on behavioral edge cases, but overall strong for this complexity level.

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

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

Schema description coverage is 0%, so the description must compensate, but it only mentions "token" implicitly via "invite token." It doesn't specify the token's format, source, or that it's the single required parameter. The term "invite token" does echo the parameter name and gives limited semantic meaning, but an agent might benefit from knowing where to obtain the token or any length/encoding constraints. This earns a minimal 3 rather than lower because the description does tie the parameter to the redeem action.

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 (Redeem), the resource (invite token), and the effect (bind this session actor to the invited identity and activate the membership). The additional note "Pre-workspace, because the accepter is not a member yet" gives important context that disambiguates it from other invite/member tools like invite_member or revoke_member.

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

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

The description explains the context for using this tool (pre-workspace, accepter not yet a member), which helps an agent decide when to invoke it. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of full exclusion guidance. It's clear enough for an agent to identify the right scenario but lacks explicit alternatives.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden. It does reveal that calling the tool can either set or clear the default, but it omits details such as whether clearing is achieved by omitting the optional taxCode, whether the change is reversible. For a mutation tool with zero annotation coverage, this is a meaningful behavioral gap.

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

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

The description is one efficient sentence with no filler and the core operation is front-loaded. It is concise, though it sacrifices important behavioral and parameter details.

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

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

Given three parameters, no output schema, and no annotations, the description is not complete enough for an agent to call correctly. The main gap is the mechanism for clearing the default tax code: the schema marks taxCode optional, but the description never says that omitting taxCode clears the value. It is an adequate statement of purpose, not a complete operational definition.

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

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

Schema description coverage is 0%, and the description adds only a general reference to the default tax code. It does not explain the taxCode parameter's role beyond implying it is the value to set, and it does not say how clearing is indicated given taxCode is optional. The schema properties are named clearly, but at 0% coverage the description does not compensate enough for undeclared semantics such as how clearing works.

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 ('Set or clear) with a specific resource (an account's default tax code. This precisely states what the tool does and differentiates it from related but distinct tools such as update_account and set_vat_method. The scope is clear enough that an agent selecting among the tax and account siblings can identify it without inspecting the schema.

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

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

The description gives no when-to-use guidance about how to choose this tool over alternatives, and it does not mention alternatives such as set_vat_method or update_account. There is also no indication of when one should clear versus set a tax default rather than use another VAT configuration tool.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: saves as a draft, returns the exact lines the post would write, includes reversal lines dated the day after, and explicitly states nothing is posted. This covers the most critical side effects, though it does not address idempotency or error handling, which are less critical for a draft action.

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 that front-loads the purpose and then explains parameters in a list-like fashion. Every phrase adds value, but the density might make it slightly harder to parse. It is concise without fluff, though structuring as bullet points could improve readability while retaining brevity.

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 10 parameters, no output schema, and no annotations, the description covers the essential aspects: the main behavior, parameter semantics for the most critical fields, and the expected return (draft lines and reversal lines). It does not explain all parameters, but the missing ones are peripheral. The explicit note that nothing is posted adds important context.

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

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

Schema description coverage is 0%, so the description must compensate. It provides rich semantics for the core parameters: kind (with enum-like values and account numbers), contraAccount (P&L account type), amountMinor (integer Rappen), and periodEnd (balance-sheet date). However, other parameters like costCenterId, sourceRef, and idempotencyKey are not explained, though they are likely self-explanatory or standard.

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: to describe an Abgrenzung (Swiss accrual) and save it as a draft. It uses a specific verb ('describe' and 'save') and resource ('Abgrenzung'), and the final sentence 'Nothing is posted' distinguishes it from posting-related siblings like accrual_post.

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

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

The description gives clear usage context by explicitly stating this creates a draft and that nothing is posted, implying it is the safe precursor to posting. However, it does not explicitly name alternative tools like accrual_post or accrual_reverse, leaving some inference to the agent. The sibling list includes these related tools, providing additional context.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the row is not deleted but remains on record with status `discarded` and a reason, and it names a specific error condition (`already_posted`). It does not mention idempotency effects or reversibility, but the core behavioral profile is clearly communicated.

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 well-structured sentences with no filler. The primary action and lifecycle constraint are front-loaded, and the error/alternative guidance follows naturally. Every sentence earns its place.

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

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

The description covers the central behavior, state transition, and error case, but it omits important invocation details such as the meaning of `idempotencyKey` and what the response looks like. Since there is no output schema and no annotations, these omissions leave the description slightly incomplete for an agent making a fully informed call.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only adds meaning for `reason` by noting that the retained row keeps the reason. Required parameters like `workspaceId`, `accrualId`, and especially `idempotencyKey` are left completely unexplained, which is a meaningful gap.

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

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

The description states a specific action ('Retire a drafted Abgrenzung before it posts') and clearly identifies the resource. It also differentiates the tool from the reverse operation by explaining that posted accruals cannot be discarded. This makes it immediately distinguishable from siblings like accrual_post and accrual_reverse.

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

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

The description explicitly says when to use the tool ('before it posts') and when not to use it ('a posted accrual cannot be discarded'), and names the alternative behavior ('reverse it instead'). This is direct, actionable guidance with no reliance 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 readOnlyHint=true annotation already declares the read-only safety profile, and the description aligns with it by opening with 'Read'. The description adds meaningful context beyond the annotation by disclosing what is actually returned (row, lines, reversal lines, journal entries, Storno pair) and notes the provenance consistency ('from the same function the post uses'). This is useful behavioral detail for an agent deciding what it can rely on.

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

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

The description is one front-loaded sentence with no filler; the verb 'Read' appears immediately and each subsequent clause enumerates a distinct return component. The parentheticals ('from the same function the post uses', 'the accrual, its reversal, the Storno pair') are dense but each earns its place by clarifying provenance or terminology.

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

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

For a simple two-parameter read tool backed by readOnlyHint=true, the return contents are well described and the safety profile is covered by annotations. The notable gaps are that both parameters are under-documented across schema and description, and the German term 'Abgrenzung' is used without being fully defined, so the agent needs context from the sibling accusatory set to fully understand the concept being read.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining the two parameters, but it never mentions workspaceId or accrualId or clarifies their meaning, format, or relationship. The only oblique connection is that 'Read one Abgrenzung' implies the accrualId selects the record; the workspace dimension is entirely unaddressed.

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 — 'Read one Abgrenzung' — and then enumerates the exact return scope: the row, its lines, reversal lines, and produced journal entries (accrual, reversal, Storno pair). This scope is specific enough to clearly distinguish it from the mutating accrual siblings (accrual_create, accrual_post, accrual_reverse, accrual_discard) and from the collection-focused accrual_list. It does not name a sibling, but the read-target and depth are 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 phrasing 'Read one Abgrenzung' implies the intended use — fetch the full detail of a single accrual record — and the listed return components imply the data depth an agent should expect. However, there is no explicit guidance about when to prefer this tool over accrual_list or the read-style siblings (e.g., provision_get), and no exclusions or prerequisites are stated.

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

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

Beyond the readOnlyHint annotation, the description discloses meaningful behaviors: results are ordered newest period first, totalMinor aggregates drafts and posted accruals, and savedViewId applies a saved view. This provides useful behavioral context without contradicting the read-only 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?

Two compact sentences deliver the core action, sorting, filters, status enum, a computed-field behavior, and saved-view semantics. Every phrase earns its place with no redundancy or padding.

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

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

The description covers the essential call dimensions: filtering, ordering, and the special totalMinor/savedView behaviors. It does not document output structure or pagination, but given no output schema exists, but the core information needed to invoke the tool correctly is present.

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

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

With 0% schema description coverage, the description compensates by explaining the filter semantics for periodEnd, status (with explicit allowed values), kind, and savedViewId. It does not define periodEnd format or kind value options, but it adds substantial meaning beyond the bare parameter names.

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

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

The description states a specific verb ('List'), the resource ('Abgrenzungen'/accruals), and concrete dimensions of the operation: newest period first, with filtering by periodEnd, status, and kind. This clearly distinguishes it from singular operations like accrual_get and from related but different list tools such as provision_list.

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

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

The description gives clear usage context by specifying sort order and available filters, so an agent knows when to call this listing tool rather than a get/create/post operation. It does not explicitly name alternatives or exclusions, but the list-vs-get distinction is strongly 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?

No annotations are provided, so the description fully carries the behavioral burden. It discloses the atomic pair, the linked automatic reversal, rollback behavior on locked reversal dates, idempotency semantics, and the specific error outcomes `already_posted` and `draft_discarded`.

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, with the core purpose front-loaded and consequences summarized. It is somewhat long, but every sentence contributes relevant operational detail for the agent.

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 lack of annotations and output schema, the description covers the key behavioral expectations, idempotency cases, and post-condition consequences. It does not specify the success response shape, but for this tool the outcome behavior is well enough described for an agent to call it correctly.

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

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

The schema has zero description coverage, but the description adds meaningful semantics for `idempotencyKey` (same key replays, different key gives error) and clarifies the operation is on a drafted accrual. It does not explicitly elaborate on `workspaceId` and `accrualId`, but their roles are inferable from the context and naming.

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

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

The description clearly states a specific verb ('Post') and resource ('drafted Abgrenzung'), and immediately defines the operation as an atomic pair of entries. It distinguishes itself from siblings like accrual_reverse and accrual_discard by emphasizing the posting of a draft and linking to its 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?

It conveys when to use the tool: when a drafted accrual exists and needs to be posted. It also hints at the alternative for correction ('the only correction afterwards is a reversing pair'), though it does not explicitly name a sibling tool like accrual_reverse for that follow-up.

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 behavioral traits: it does not edit history, it posts a mirror pair (Storno dated periodEnd and its own reversal dated the day after), and it refuses certain states. It also warns of the consequence: posting the mirror pair so every account nets to zero. This goes beyond a simple 'reverses an accrual' statement and explains the accounting mechanics. With no annotations provided, the description carries the full burden, and it does so well, though it could mention idempotency behavior or side effects on related records.

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 dense and information-rich, with the core action and consequence front-loaded. The first sentence explains the mechanism and the second adds constraints and a warning. It is slightly redundant: 'posts the MIRROR pair' and 'CONSEQUENCE: Posts the mirror pair' repeat the same action. Trimming the second sentence's repetition would make it tighter, but overall it is concise and well-structured.

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

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

Given the tool's complexity (accounting reversal with mirror entries, state refusals, no output schema), the description covers the essential behavioral contract: what it does, when it refuses, and the net effect. It does not explain the return value or how to interpret success/failure beyond the refusal states, and it does not detail the `reason` parameter's role. However, for an agent deciding whether to call this tool, the description is largely complete. The lack of output schema and 0% parameter coverage raise the bar, and the description meets it for the core decision but leaves some gaps around parameter specifics and response handling.

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

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

Schema description coverage is 0%, so the description must compensate for the four parameters. The description mentions `periodEnd` and `already_reversed`/`not_posted` states, which relate to the accrual being reversed, but it does not explicitly explain the meaning of `workspaceId`, `accrualId`, `idempotencyKey`, or `reason`. The `accrualId` is inferable from the tool's purpose, and `idempotencyKey` is a common pattern, but the description does not add explicit parameter-level semantics. It provides some context (the reversal is dated periodEnd), but not enough to fully compensate for 0% schema coverage.

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

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

The description clearly states the tool's purpose: reverting a posted Abgrenzung (accrual) by posting a mirror pair of entries, with specific dates, so all four entries net to zero. It distinguishes itself from related tools like accrual_discard (which likely handles drafts) and provision_reverse by specifying it operates on a posted accrual and refuses drafts. The verb 'Revert' plus the resource 'posted Abgrenzung' is specific and unambiguous.

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

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

The description explicitly states when the tool can be used: on a posted accrual, and when it cannot: it refuses `already_reversed` a second time and `not_posted` on a draft. This gives clear preconditions and failure modes. However, it does not explicitly name alternative tools for reversing drafts or other reversal scenarios, though the sibling list includes accrual_discard and provision_reverse. The context is clear enough for an agent to know when to invoke this tool, but it lacks explicit 'use X instead' guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It reveals that it is not a gate, that timestamps are claims not proof, that completedAt is derived, and that direction change resets the checklist. It also explains the abandon behavior. This is comprehensive for a write operation with multiple modes.

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 detailed but every sentence adds value. It is structured logically: main purpose first, then mode explanations, then clarifications (non-gate, reset, derived timestamp). It is not overly verbose for the complexity of the tool, and the key points 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?

Given the tool's complexity (multiple modes, interactions with a checklist, derived state) and the absence of an output schema, the description covers everything an agent needs: what it does, how to use each mode, the semantics of step/done/abandon, and the derived completedAt. Nothing critical is missing 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 0%, so the description must compensate. It explains each parameter's role: direction starts/re-asserts, step (1-5) with done (default true) checks/un-checks, abandon deletes the pointer. It also explains the derived completedAt. This fully covers the parameter semantics beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Persist the move-checklist resume point'. It specifies the resource (move-checklist) and the action (persist/resume point). It also distinguishes itself from the sibling advance_onboarding_step by referencing its shape, making the distinction clear without ambiguity.

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

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

The description provides strong contextual guidance on when to use this tool: it's for the move-checklist, not for validation (explicitly 'Never a gate'). It also describes the various modes (start, check, uncheck, abandon) and how the checklist resets on direction change. It does not explicitly name an alternative tool for onboarding, but the 'advance_onboarding_step' reference implies the separation. Slight gap in naming explicit alternatives, but context is clear.

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

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

With no annotations, the description carries the full burden and does well: it states persistence is absolute, side effects are limited to bookkeeping, and completed:true is monotonic ('never un-completes it'). This gives an agent a clear mental model of side effects and irreversibility.

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

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

Two sentences, front-loaded with the core purpose, and each clause adds a distinct behavior (persistence, non-gating, completion semantics). The spec reference is compact but provides provenance.

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 4-parameter bookkeeping tool with no output schema, the description covers the critical invocation details: path enum, step, completed semantics, and side-effect scope. It doesn't specify the allowed format of step or workspaceId, but these are low-risk for a persist 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 coverage is 0%, so the description must explain the parameters. It enumerates path values (fresh|import|demo), defines step as the current wizard step, and explains the completed flag's irreversible behavior. workspaceId is not explicitly described, though its meaning is conventional.

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 ('Persist') and resource ('first-run wizard resume point') and clarifies the exact payload (path, step, completed). It also distinguishes itself from real setup operations by stating 'Never a business-logic gate,' which differentiates it from sibling migration/setup tools.

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

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

It provides explicit when-not-to-use guidance: 'an agent session skips this bookkeeping entirely' and clarifies it is not a validation or gate mechanism. It doesn't name alternative tools (e.g., get_onboarding_progress), but the exclusions are clear enough to prevent misuse.

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

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

With no annotations provided, the description carries the burden and does more than most: it discloses the runtime requirement, guarantees no write is reachable, and reveals side effects (persisting the turn and recording the call in the trace). It is missing caveats like authorization, failures, or rate limits, but the core behavioral profile is unusually explicit.

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

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

The description is dense and information-rich, with the primary action front-loaded and no filler sentences. The internal code names and parentheticals reduce clarity, but every clause carries either a constraint, a side effect, or a purpose.

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

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

For a complex tool with no annotations, no output schema, and no parameter descriptions, the definition is incomplete: it does not state what the answer looks like, how period filters interact with the question, or how idempotency applies. It provides strong behavioral context but leaves invocation semantics underspecified.

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

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

Schema description coverage is 0%, and the description only obliquely covers 'text' as the prose question. It never explains workspaceId, periodStart, periodEnd, or idempotencyKey, which an agent needs to invoke the tool correctly. The description does not compensate for the schema's lack of parameter documentation.

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

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

The description clearly identifies a verb and resource: 'Ask the books a question in prose,' and adds that the verb is always a read, distinguishing it from write-oriented sibling tools. However, the meaning of internal codes like 'D90 D-1' and 'A26 read models' is opaque, and the description never explicitly says what the tool returns.

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

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

It states a clear prerequisite ('Needs a registered E05 local runtime') and implies the intended use is natural-language questions over the books. But it gives no explicit guidance about when not to use this tool or which sibling to prefer, e.g., ledger_qa or detect_anomalies, so routing is left to inference.

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

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

With no annotations, the description carries the burden of disclosing behavioral traits. It reveals important details: clears all turn text, preserves call trace, requires owner-gate (manage_agent_dial), and is idempotent. However, it doesn't state what happens to the session itself or whether deletion is reversible.

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

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

Description is concise, with key information front-loaded: the action, scope, and implications are stated in the first sentence. Later sentences add ownership and idempotency details without redundancy. Could be slightly more structured but is well within appropriate 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?

The description is adequate for a simple deletion tool but lacks essential parameter semantics and does not clarify the return value or error states. Given the tool's complexity (3 params, no output schema), it could provide more detail on what the agent should expect after deletion.

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

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

Schema description coverage is 0% and the description provides no explanation of the parameters (workspaceId, sessionId, idempotencyKey). It only mentions the idempotency key indirectly by saying 'idempotent per key,' but gives no format or usage details for any parameter.

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 deletes a specific agent session's stored prose and specifies the scope (every turn text cleared, call trace remains). It distinguishes itself from sibling tools like agent_trust_summary and get_agent_session by focusing on deletion, though it doesn't explicitly name a sibling alternative.

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

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

Provides context on when to use (owner-gated, idempotent per key) and implies it's for removing user-authored text while preserving the audit trail. However, it doesn't explicitly state when not to use it or mention alternative tools for related operations.

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 the description goes further by stating the data is 'derived from the trace at read time; never stored, never a score.' This adds meaningful behavioral context beyond the annotation, preventing misconceptions about persistence and semantics.

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 focused sentences convey the resource, the exact contents, the time-window behavior, and the key semantic caveat ('never a score'). No filler or repetition; the most important qualifiers 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?

Given no output schema, the description enumerates the main return contents and clearly states the computation and persistence model. It lacks exact response structure and date format details, but for a simple read-only evidence tool, it is nearly complete.

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

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

Schema coverage is 0%, so the description must compensate. It adds the concept of a 'stated window (default the last 90 days)', giving some meaning to the from/to parameters, but it does not name them, specify date formats, or clarify the required workspaceId. The compensation is partial but not complete.

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

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

The description names the specific deliverable ('trust evidence per dial capability'), enumerates the data it returns (stored/effective levels, who set it, when, counts over window), and explicitly distinguishes it from a score. This differentiates it from sibling tools like get_agent_dial and set_agent_dial.

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

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

The description provides clear context: this is a read-only, trace-derived evidence view over a default 90-day window. It implies when to use it (when historical trust evidence is needed) without explicitly naming alternatives, but the context is sufficient for an agent to route correctly.

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

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

The annotations provide readOnlyHint=true, and the description reinforces this with 'Reads only.' It adds useful behavioral context beyond that: the relationship to baseTotalOpenMinor in multi-currency workspaces conveniently ties to reconciliation flags against account 1100 Debitoren. No contradiction exists between description and 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 dense but efficient: each sentence contributes meaningful information (report nature, aggregation method, currency handling, use case, reconciliation flag, read-only status). It is front-loaded with the core summary, though it could be slightly trimmed without losing value.

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

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

Given there is no output schema, the description does a decent job of explaining the report's output shape: totals per bucket and customer, and the difference between byBucket and baseByBucket. However, it does not mention the asOf parameter or any pagination/limits for large result sets, leaving some operational context missing. For a read-only report, this is a moderate gap.

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

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

The schema has 0% description coverage, providing only parameter names (workspaceId and asOf) without any meaning. The description does not explain these parameters at all; it only mentions output-related fields like byBucket and baseByBucket. The agent must guess what asOf does (likely a date for the aging snapshot), and workspaceId is presumed from the required flag. This is a clear gap in compensating for the schema's lack of detail.

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

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

The description clearly states what the tool does: it provides a receivables summary totalled per aging bucket and per customer, with the largest debtor first. It explicitly differentiates itself from list_open_items by noting it is the same open items 'totalled' rather than itemised, and gives a concrete use case ('how much is over 90 days overdue and who owes it').

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

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

The description provides a clear usage context: 'Use it to answer ... in one call.' It also references list_open_items as the underlying itemised view, implying the alternative for detailed line items. However, it does not explicitly state when not to use this tool or mention other alternatives, so it lacks exclusion 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?

No annotations exist, so the description carries the full burden. It discloses the critical side effects: no posting at allocation time, the record of which open items are settled, and that the settlement posts to the ledger. It also explains how a wrong allocation is corrected, which is important for a consequential mutation.

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

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

Front-loaded with the core action and kept to a few sentences; the correction and consequence details earn their place. The CONSEQUENCE line somewhat restates the opening sentence, adding minor redundancy but no significant bloat.

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

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

Covers the prerequisite (payment already booked), required intent, ledger side effect, and correction method, which are the hard-to-infer parts. It does not describe the allocation object fields or the return/idempotency behavior, and there is no output schema, but it is reasonably complete for a well-scoped action.

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?

Adds meaning to intent (exact required value), paymentId (the already-recorded payment), and allocations (they target open items). However, with 0% schema description coverage, it leaves the allocation subfields (skontoMinor, writeOffMinor, targetKind, etc.) and idempotencyKey semantics largely unexplained, so compensation is only partial.

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 action ('Allocate') on a concrete resource ('parked Guthaben'/'recorded payment') to open items, and clarifies that it posts no new payment entry because the money was already booked. This semantically distinguishes it from sibling payment-recording tools despite no sibling being named.

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 clear context: this tool is for payments already booked when they arrived, requires intent='allocate_payment', and gives the correction path (reverse the whole payment and record it again). It does not explicitly name alternatives or state when not to use it, so it stops short of a full 5.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It discloses the posting delegation, net-of-credit-note behavior, mode defaults, write-off threshold, exact error outcomes (write_off_above_threshold, currency_mismatch, already_applied), idempotency guarantees, and the P8 confirmation requirement. It even states the settlement is only undoable by reversal and that a stored rule may never make this judgment, which is far beyond the minimum.

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

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

The description is long and dense, but every paragraph addresses a distinct aspect: mechanism, netting, mode semantics, safeguards, idempotency, and consequence. It is front-loaded with the action verb and structured with labels like 'CONSEQUENCE'. Minor redundancy exists between the opening action and the consequence statement, but overall the length is justified by the high-risk domain.

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 and lack of an output schema, the description covers the main outcomes, failure modes, and automation constraints well. It names specific error identifiers and explains the operational consequence. It does not describe the expected return payload or required permissions, but for selection and invocation correctness this is largely sufficient.

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

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

The schema has zero description coverage, but the description compensates well for the most ambiguous parameters: mode is fully explained (partial vs full, write-off threshold), confirmed is connected to the P8 rule, and idempotencyKey semantics are implied by the idempotency statement. It does not explicitly define creditId, invoiceId, or workspaceId, though these are inferable from context, so the compensation is strong but not exhaustive.

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: 'Settle an invoice from a queued credit', and immediately distinguishes the tool from record_payment by stating it delegates posting to A14 record_payment (source 'qr') and that A21 posts nothing itself. It is clear which object the tool acts on and how it relates to the payment pipeline, setting it apart from nearby siblings.

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

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

The description gives explicit conditions for mode usage, states the alternative path for larger write-offs ('type a deliberate larger Ausbuchung through record_payment'), and includes a firm automation restriction ('NOT automatable (D77)'). However, it does not directly contrast with closely related siblings like match_qr_payment or override_qr_match, so an agent is not fully told which tool to choose among those.

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

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

With no annotations provided, the description fully carries the burden of behavioral disclosure. It explicitly mentions idempotency ('approve-twice never double-posts'), RBAC re-checking, the side effect of allowFuture (recording a standing grant via set_agent_dial), the self-approval prohibition, and the owner-gating requirement. These are significant behavioral traits beyond what the schema reveals.

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 paragraph but avoids fluff. It front-loads the primary purpose, then adds crucial behavioral details. Every clause contributes information about idempotency, permissions, side effects, or constraints. It is appropriately sized for a tool with three parameters and no output schema.

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

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

Given the tool's complexity (3 params, no output schema, no annotations), the description covers all essential aspects: what it does, how it does it, idempotency, permission requirements, side effects of allowFuture, self-approval restriction, and owner gating. An agent has enough information to decide when and how to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must clarify parameters. It explicitly explains allowFuture: 'records the standing per-capability grant to auto (D103): the same attributed, revocable dial write set_agent_dial performs.' workspaceId and actionId are inferable from the action context ('from the inbox', 'drafted agent action'), though not explicitly defined. This adds meaning beyond the bare schema.

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

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

The description states the precise action: 'Approve a drafted agent action from the inbox' with a clear verb and resource. It further explains the mechanism ('replay its verb through the shared dispatch as the approver') and distinguishes it from sibling actions like reject_drafted_action and list_drafted_actions by focusing on approval semantics.

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 usage context: 'The agent can never self-approve; a second, independent actor must review' and 'Owner-gated (manage_agent_dial)' indicate when and by whom the tool should be used. It does not explicitly contrast with alternatives, but the purpose is clear enough that an agent can infer when to use this tool versus rejection.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states the operation is metadata-only, does not lock or alter the entry, handles already-reversed entries with an alreadyReversed report, and imposes a human-approval constraint. It lacks response-format details but covers the most important behavioral traits.

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

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

Three sentences with no filler: the core effect is front-loaded, the edge case follows, and the permission constraint closes the description. Each sentence contributes meaningful decision-relevant information.

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

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

The description is behaviorally rich but incomplete for invocation: the required idempotencyKey is unexplained, the note parameter is ignored, and there is no output schema to clarify the response or alreadyReversed return shape. Given four parameters and zero schema descriptions, an agent would still need external knowledge to call this correctly.

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

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

Schema description coverage is 0%, and the description does not compensate. It only refers to 'one checked entry' but never explains the workspaceId, entryId, idempotencyKey, or note parameters. An agent cannot infer idempotency semantics or which parameter identifies the entry from either schema or description.

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

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

The description states a specific action ('Sign off one checked entry') and its exact effect ('sets its review status to approved'), so an agent knows precisely what the tool does. It also distinguishes this from sibling approval tools like approve_drafted_action and expense_claim_approve by clarifying it targets checked entries and is metadata-only.

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

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

The description gives clear context: it is a human sign-off, requires the review capability (Treuhänder/owner), and must not be fired by automation rules. It does not explicitly name alternatives or state when not to use this tool, but the permission and human-act constraints effectively guide 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?

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the operation is soft and preserves postings, which is a meaningful side effect. However, it does not mention reversibility, what happens to future postings, or visibility effects, leaving gaps in the behavioral picture.

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

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

A single sentence with no filler. The core action is front-loaded and the critical qualifier '(soft; the account keeps its postings)' is placed immediately, giving the agent the most important behavioral fact without extra 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 two-parameter tool, the description covers the essential purpose and the most important side effect. It is minimally viable, but it omits contextual hints such as reversibility via unarchive_account or implications for postings/reporting, which would make it fully complete.

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

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

Schema description coverage is 0%, so the description should compensate for the undocumented parameters. It adds no information about workspaceId or accountId beyond their obvious names. Since the parameter names are self-explanatory, this is not a complete failure, but the description provides zero semantic addition.

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 ('Archive') and resource ('account'), and the parenthetical '(soft; the account keeps its postings)' distinguishes it from a hard delete. It is clear enough to separate from delete_account, though it does not explicitly contrast with unarchive_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 unarchive_account or delete_account. The 'soft' hint implies a non-destructive use case, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden, and it thoroughly discloses the operation's safety profile: 'Never a delete' and 'run history is untouched' clarify both irreversibility and data preservation. It also explains the behavioral side effects beyond just saying 'archive,' going well beyond what the schema could 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?

Two sentences, front-loaded with the core action and its main effects. The prose is efficient and meaningful; the 'firing that happened stays true' phrase adds color but reinforces an important guarantee, so the extra length still earns its place.

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

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

For a simple two-parameter tool with no output schema, the description covers what changes, what does not change, and the non-delete nature, which is enough to invoke it correctly in most cases. It omits explicit return or error behavior and parameter details, but the tool's simplicity makes those omissions less critical.

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

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

Both parameters are bare strings with zero schema descriptions (0% coverage), and the description adds no guidance on their semantics or format. The names 'workspaceId' and 'ruleId' are self-explanatory, but the description does not compensate for the missing schema documentation.

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

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

Opens with 'Retire a rule,' naming a clear verb and resource, then spells out three concrete effects: stops matching, disappears from the default list, and stops being enable-able. This clearly distinguishes it from enable, disable, and delete semantics.

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 useful context by stating the permanent consequence ('stops being enable-able') and explicitly ruling out delete, which helps an agent infer this is the terminal option. However, it never names sibling tools such as disable_automation_rule or states when to choose that alternative instead, so the selection guidance 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?

With no annotations, the description carries the burden of behavior disclosure. It reveals the key behavioral traits: hides from pickers, retains historical references, and never deletes. This goes well beyond the schema but doesn't mention idempotency, reversibility, or effects on existing picker selections.

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

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

A single sentence that front-loads the verb and core purpose, then adds the critical non-deletion guarantee. No waste; every clause earns its place.

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

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

The description covers the essential behavior but omits prerequisites (e.g., account must be closed), what the response contains, and the connection to unarchive_bank_account. With no annotations and no output schema, more operational detail would be expected for full 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 0%, and the description does not explain workspaceId, bankAccountId, or idempotencyKey. While the names suggest their roles, the description adds no parameter-level guidance, so it fails to compensate for the schema gap.

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

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

The description states a specific action (hide a closed bank account from pickers) and resource (Bankkonto), and clarifies the key distinction from deletion: 'Never deletes the account.' This clearly separates it from delete_account and other destructive archive tools.

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

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

It provides clear context: use for closed bank accounts that should be hidden from pickers but remain referenceable. It does not explicitly name alternatives like unarchive_bank_account or state when not to use it, which prevents a 5, but the context is specific enough to guide 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?

With no annotations, the description carries the full burden of behavioral disclosure. The parenthetical 'soft' is genuine behavioral information: it indicates the contact is not permanently destroyed and can likely be restored. However, it does not disclose side effects, permissions, idempotency, or what happens to associated data, so transparency is only partially addressed.

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

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

The description is a single efficient sentence with no filler words, and the core action is front-loaded. It is appropriately short for a simple two-parameter tool. However, the brevity comes at the cost of missing usage and behavioral context, so it stops just short of an exemplary score.

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

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

For a tool with no annotations and no output schema, the description is too sparse to be considered complete. It says nothing about the result of archiving, whether the contact disappears from lists, or how the operation can be reversed. The agent can guess the basics from the name and the word 'soft,' but meaningful context is missing.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation, but it does not mention either parameter. The names workspaceId and contactId are somewhat self-explanatory, yet the description adds no meaning beyond the raw schema. This is a clear gap given 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 names a specific verb and resource: 'Archive a contact.' The parenthetical 'soft' adds important meaning that this is not a hard delete, which helps distinguish it from deletion-style tools. It does not explicitly name sibling tools like unarchive_contact, but the core purpose is still clear.

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

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

There is no guidance on when to use this tool versus alternatives such as unarchive_contact, update_contact, or other archive operations. The word 'soft' implies a reversible action, but the description does not state when archiving is appropriate or how to reverse it. This leaves usage decisions entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Archive a cost centre (soft)' implies a mutation but does not say whether it is reversible, what the soft-archive state means, whether it prevents editing or deleting, who can perform it, or what happens to associated data. The word 'soft' hints at reversal but is not elaborated.

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

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

One short sentence that is easy to parse and front-loads the verb and object. The parenthetical '(soft)' is a useful qualifier, though it could be more explicit. No wasted words, but the conciseness comes at the cost of missing necessary detail.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, this description is incomplete. It lacks prerequisites (e.g., existence of the cost center), what happens after archiving, whether the operation is reversible, and parameter meaning. The sibling set includes lifecycle tools (create_cost_center, unarchive_cost_center, delete_cost_center, list_cost_centers), but the description does not situate this tool within that lifecycle.

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

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

Schema description coverage is 0%, so the two parameters (workspaceId, costCenterId) are entirely undocumented. The description names neither parameter and provides no hint about formats, scoping, or dependencies. An agent must guess which workspace and cost center identifiers are expected.

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 'Archive a cost centre (soft).' clearly states the action (archive) and the resource (cost centre), and the parenthetical '(soft)' usefully indicates this is a soft archive (reversible, not a hard delete). It is distinguishable from the sibling tools 'delete_cost_center' and 'unarchive_cost_center'. However, it doesn't explicitly state that this is a status change or describe the state transition, which would add clarity.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like 'delete_cost_center' or 'unarchive_cost_center'. The '(soft)' hint implies a contrast with hard delete, but it doesn't state the relationship or offer decision criteria. An agent would have to infer usage from the name and sibling proximity.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does so excellently. It discloses that the operation is non-destructive, that templates frozen onto issued documents continue rendering forever, and that archiving only affects active availability and default selection. This is precisely the kind of behavioral detail an agent needs.

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

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

The description is two tight sentences with no filler. The core action is front-loaded, and the clarifying non-destructive detail immediately follows in a parenthetical that earns its place.

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

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

For a tool with two required simple parameters and no output schema, the description covers the action, the side effect, the non-destructive guarantee, and the ongoing impact on issued documents. The only minor gap is that it does not mention the purpose of idempotencyKey, but that is a standard parameter and not critical 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 0%, so the description should compensate for the parameters' meaning, but it does not explain workspaceId, templateId, or idempotencyKey beyond referencing 'a template' in general terms. The parameter names are somewhat self-explanatory, but the description adds no semantic value to the schema.

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

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

The description states a specific verb ('soft-archive'), the resource ('a template'), and the side effect ('clear it as default'), making the tool's purpose immediately clear. It also distinguishes itself from destructive operations by explicitly saying 'NOT destructive', which is meaningful given the sibling set contains many archive/delete tools.

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

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

The description explains the practical consequence—archiving removes the template from the active list and from new defaults while preserving rendering on already-issued documents—so an agent can judge when this is appropriate. It does not explicitly contrast with a delete/unarchive alternative, but there is no obvious sibling that would compete for the same call.

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

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

With no annotations, the description carries the full burden and does well: it reveals that archiving is non-destructive, that values remain readable, and that the response includes a count of saved views still referencing the field. It does not mention reversibility or permissions, but the most decision-relevant behaviors are disclosed.

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

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

Three tight sentences: the main purpose comes first, followed by the critical non-destructive guarantee, then the useful return-value behavior. No filler or repetition.

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

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

For a tool with no annotations and no output schema, the description covers the essential call context: what it does, what it does not do, where data remains readable, and what the caller should do with the response. The only notable gap is a lack of parameter-level detail, but the required IDs are reasonably inferable.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain workspaceId, fieldDefId, or idempotencyKey. It only implies fieldDefId identifies the custom field. The parameter names are self-explanatory to a degree, but the description adds little semantic value beyond the schema.

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

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

The description states a specific verb ('Archive'), a specific resource ('a custom field'), and the concrete effect ('stops being offered as an input'). It also draws a clear line against deletion, which distinguishes this from destructive sibling 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?

It gives clear contextual guidance: use this when you want to stop offering a field while preserving stored values. The explicit 'Never a delete' warning and the pointer to list_field_values provide useful boundaries, though it does not name a specific non-archive alternative.

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

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

With no annotations, the description carries the full burden of disclosing behavior. The word 'soft' hints that the operation is non-destructive, but it does not explain side effects (e.g., whether the item disappears from listing, whether it can be restored, what happens to related entities). For a mutation tool, this is a significant gap.

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

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

The description is a single, short sentence with no redundant words, which is concise. However, its brevity results in under-specification; it is not structured to convey key information. It is minimal but incomplete, so it earns a middle score.

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

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

For a tool with two required parametersrande no annotations or output schema, the description is far too sparse. It omits the action semantics (what 'soft' means), the effect on item availability, any permission requirements, and the expected response. An agent cannot reliably invoke this tool correctly based solely on the description.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It does not mention workspaceId or itemId at all. While the parameter names are somewhat self-explanatory, the description adds no context, semantics, or format expectations, leaving the agent to infer complex requirements like workspace context.

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

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

The description states a clear verb ('Archive') and resource ('item'), and the parenthetical '(soft)' signals that this is a non-destructive operation, distinguishing it from a hard delete like delete_item. However, it does not explicitly contrast with unarchive_item or define what 'soft' means in this domain, so the clarity is good but not fully comprehensive.

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

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

No guidance is given about when to use this tool versus alternatives like unarchive_item, delete_item, or archive_account. The description provides no context on prerequisites, reversibility, or selection criteria. An agent is left to infer usage from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the operation is non-destructive, that it keeps historical attributions resolving, and that it fails with 'role_in_use' when the role is still assigned. This is strong transparency for a soft-delete 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?

Two tight sentences front-load the core behavior and then add the critical safety distinctions. Every word earns its place, with no filler or repetition.

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

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

For a straightforward soft-archive operation, the description covers the essential behavioral semantics, the key failure condition, and the non-delete nature. It does not address idempotency behavior or reversal, but these are secondary 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 description coverage is 0%, and the description does not compensate by explaining the parameters. 'roleId' and 'workspaceId' are self-explanatory from their names, but 'idempotencyKey' is left completely unexplained, and no parameter-level guidance is added.

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

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

The description clearly states the specific action ('Soft-flag'), the resource ('a custom role'), and the observable effect ('stops being offered'). It explicitly differentiates itself from a delete operation, which is essential for tool selection.

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

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

The description provides clear usage context: this is not a delete, it preserves historical attributions, and it will be refused while any member holds the role. It stops short of naming an explicit alternative tool, but the conditions and exclusions are well stated.

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

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

With no annotations provided, the description carries the full disclosure burden and fully meets it: it declares reversibility ('a reversible flag'), data preservation ('the books stay intact and exportable'), continued read access ('reads keep answering'), and the workspace_archived error on other writes. This gives an agent an accurate behavioral model without needing to test the tool.

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

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

Two sentences, front-loaded with the purpose, and covering side effects economically. The only waste is the 'Archivieren:' prefix, which duplicates the tool name, and the cryptic '(OR 958f)' reference that may read as noise for an agent. Overall the density of useful information per sentence is high.

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 3-param tool with no output schema and no annotations, the description covers purpose, both flag directions, data preservation, and blocked-write behavior — enough to call correctly. The remaining gaps are the return value (unknown, since no output schema exists) and the semantics of idempotencyKey, which are minor for a simple toggle 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?

With 0% schema description coverage, the description compensates for the key semantic parameter: it defines both archived:true and archived:false outcomes in depth, which is the parameter carrying real meaning. workspaceId is self-evident from the tool name, but idempotencyKey's purpose (why it is required, what value to supply) is left unexplained — a real but minor gap given its conventional meaning.

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

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

The description opens with the specific action — 'retire a finished mandate (archived:true) or put it back in play (archived:false)' — giving a clear verb, resource, and both flag states. The workspace scoping and the 'never a delete' clause distinguish it from the many archive_account/archive_contact/archive_item siblings and destructive delete tools. Nothing about the purpose is ambiguous.

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 names the condition to use the tool: a mandate is finished (archive) or needs reactivation (unarchive). The 'never a delete' statement is an explicit when-not, telling the agent this is not the tool for permanent data removal. However, it stops short of naming a specific sibling alternative for permanent deletion (e.g., env_delete, delete_account), so guidance is context-rich but not fully explicit.

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

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

Since no annotations are provided, the description carries the full burden. It thoroughly discloses behavior: atomic transaction, GL posting, state transitions, idempotency on idempotencyKey, consequences (financial-field lock), and error conditions. It adds rich context beyond the schema.

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

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

The description is long but information-dense, with each sentence adding value. It front-loads the primary purpose and then lists constraints and consequences. Slightly overlong but justified given the complexity of the operation.

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 high parameter count (11) and zero schema coverage, the description is remarkably complete. It covers all major aspects: atomicity, accounting effect, validation errors, idempotency, and post-conditions. An agent can confidently invoke this tool without further research.

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

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

Schema coverage is 0%, so the description must compensate. It explains several parameters: creditAccountId must be a real account, residualValueRappen within 0..cost, source and sourceDocumentId linkage, idempotencyKey for replay. It does not explain all 11 parameters but covers the critical ones, leaving a minor gap for date/workspaceId/etc.

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 records the PRIMARY acquisition of a draft fixed asset (H02), the first financial event that capitalises the asset. It specifies the exact verb, resource, and unique purpose, distinguishing it from siblings like asset_add_capitalisation or asset_dispose.

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 mentions when to use this tool (for primary acquisition, when the asset is in draft state) and lists refusal conditions (e.g., asset_not_acquirable, already_acquired). However, it does not explicitly contrast with alternatives like asset_add_capitalisation, though the context of 'primary acquisition' implies 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 declare readOnlyHint=true and the description aligns with it by stating 'Pure read, §H-TENANT'. Beyond the annotation it adds valuable behavioral context: ISO dates are inclusive, an empty range is an empty success, footer totals are returned, and the source field covers source_document_type or 'manual'.

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

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

A dense single sentence enumerating output fields, followed by two short sentences for totals, empty-range behavior, and read-only status. Front-loaded with the purpose; every element earns its place, though the field enumeration makes it long.

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?

Since there is no output schema, the description carries the full burden of describing the return shape, and it does so thoroughly: all fields, footer totals, filters, and the empty-range success behavior. Missing only minor details such as result ordering and pagination limits.

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 0% schema coverage, the description must compensate. It adds meaning for fromDate/toDate (ISO, inclusive) and filter.categoryIds/locationIds (optional), but the required workspaceId parameter is never mentioned, leaving a gap for a required input.

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

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

The description names a concrete resource and scope: 'What was capitalised in a period (H09, US-H09.5)' covering acquisition and additional-capitalisation events (H02). It lists output fields explicitly and is clearly distinguishable from siblings like asset_acquire (a mutation), asset_transaction_list (all transactions), and asset_depreciation_* (depreciation).

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 clear usage context: it is the H09/H09.5 capitalisation report, a pure read, with date-range and optional category/location filters. It does not explicitly name alternatives or state when-not-to-use, but the scope definition is precise enough to route an agent correctly.

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

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

With no annotations present, the description fully carries the behavioral disclosure burden. It spells out the atomic transaction, the exact sub-ledger entry type, the posting pattern, the effect on acquisition_cost_rappen and net_book_value_rappen, what stays unchanged (accumulated depreciation, residual, useful life), and idempotency on idempotencyKey.

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: definition first, then atomic mechanics, prerequisites, shared rules, idempotency, and consequence. The final CONSEQUENCE sentence is mildly redundant with the opening, but the overall density and organization still make this an efficient, valuable description.

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 multi-step mutation with no annotations and no output schema, the description is unusually thorough: it covers effects, unchanged fields, prerequisites, error conditions, and idempotency. It is not fully complete because parameter-level semantics are only partially described and no return/output information is given, but the critical behavioral contract is present.

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

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

The schema has 0% description coverage, so the description must compensate. It does explain amountRappen and creditAccountId via the posting pattern and idempotencyKey via idempotency, and it alludes to shared source-document rules. However, it leaves workspaceId, assetId, date, source, description, costCenterId, and sourceDocumentId without explicit semantics, so not all parameters are fully clarified.

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 precise verb and object: 'Capitalise ADDITIONAL cost onto an already-acquired asset (H02): an improvement or major overhaul.' This clearly distinguishes the tool from initial acquisition tools like asset_acquire and from disposal/transfer tools, making its purpose unmistakable.

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 prerequisites ('Requires a live asset carrying a primary acquisition'), failure conditions ('not_acquired otherwise; asset_not_acquirable when disposed/archived'), idempotency behavior, and refers to the sibling asset_acquire for shared credit-account, source-document and period rules. This gives an agent concrete when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full disclosure burden, and it does substantial work: it discloses soft-archive semantics (leaves register, stays readable), the specific error code (asset_in_use), the rationale ('an asset the ledger still depends on cannot be hidden'), and valid starting states. It does not disclose whether the operation is reversible or what the response contains, leaving minor residual gaps.

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

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

Two tightly packed sentences with zero filler; the core action and its most important consequence are front-loaded, and the error condition, alternative, and precondition each earn their place. The H06 reference is the only slightly cryptic element, but it is not redundant.

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

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

For a 3-parameter tool with no output schema and no annotations, the description covers behavior and failure modes well, but two gaps remain: the alias 'H06' is unexplained jargon an agent may not resolve to a specific sibling, and the required idempotencyKey's role is never addressed. Reversibility (unarchive path) is also unstated, leaving the picture adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate for the three required string parameters (workspaceId, assetId, idempotencyKey), but it only clarifies the asset's semantic role implicitly via the tool's purpose. It adds nothing about the meaning or constraints of idempotencyKey — a required parameter — or how workspaceId scopes the operation, so it fails to compensate for the empty schema.

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

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

The description leads with a precise verb+resource+state-change: 'Soft-archive an asset (status=archived)' and immediately differentiates itself from hard deletion: 'it leaves the active register but stays readable.' This clearly distinguishes it from sibling tools like asset_dispose, archive_item, and asset_update without requiring the agent to open any schema.

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

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

It gives explicit when-to-use guidance by naming the error condition ('Refused with asset_in_use while the asset is active or fully_depreciated'), naming the alternative ('dispose it via H06 instead'), and stating the precondition ('Only a draft or already-terminal asset may be archived'). An agent knows exactly when to call this versus a disposal path.

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

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

With no annotations, the description carries full behavioral disclosure. It explains the exact effects (active=false, leaves default picker, stays resolvable), the failure mode (refused with category_in_use while any asset references it), and the rationale (category must stay resolvable for its depreciable life). This gives the agent a complete picture of side effects and constraints without needing 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 three sentences, each carrying essential information: the core action, the error condition, and the rationale for no deletion. It is front-loaded with the action and avoids any fluff or repetition, making it highly efficient.

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

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

Given the lack of annotations and output schema, the description covers all critical aspects: what the tool does, side effects, failure conditions, and why deletion is not offered. It even explains the 'soft-archive' nuance (leaves default picker, stays resolvable). Nothing essential is missing for an agent to invoke it correctly.

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

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

The input schema has 0% description coverage for its three parameters (categoryId, workspaceId, idempotencyKey), and the description does not mention any of them. The parameter names are somewhat self-explanatory (e.g., categoryId identifies the category), but the description adds no additional meaning about their purpose, formats, or why idempotencyKey is required. Given the low schema coverage, the description should compensate but does not.

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 soft-archives a category by setting active=false, and contrasts it with deletion. It distinguishes the tool from other category operations like asset_category_update or asset_category_delete (if it existed) by explaining the soft-archive semantics, making it unambiguous what the tool does.

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

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

The description provides clear context for when this tool is appropriate: when you need to soft-archive a category that is not referenced by any asset. It also explains the error condition (category_in_use) and states that deletion is never offered, which implicitly guides the agent away from a delete operation. However, it does not explicitly name a sibling alternative (e.g., 'use asset_category_delete for hard delete'), so it lacks an explicit when-not-to-use reference.

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

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

With no annotations, the description carries the full burden. It discloses that the tool creates a category with inherited defaults, and provides specific validation behaviors: code must be 1-20 chars and unique per workspace case-insensitively (duplicate_code), and wrong account types are refused with invalid_account_type before any write. This adds substantial transparency, though it does not mention idempotency or return values.

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

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

The description is dense but front-loaded with the core purpose. It packs a significant amount of information into three sentences without fluff. The first sentence is long and technically detailed, but every clause adds value, and the two follow-up sentences nicely summarize validation rules.

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 13 parameters, no output schema, and no annotations, the description covers essential business logic, defaults, validation, and account rules. It leaves gaps around the interaction of residualValuePct vs residualValueRappen and does not explain return values, but overall provides enough context for an agent to call the tool correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains the meaning of depreciationMethod (with enum values), usefulLifeMonths, residualValue (basis points or Rappen), the roles of the three GL accounts, and the optional defaultCostCenterId. It also specifies code length and uniqueness. However, it omits mention of the required name, workspaceId, and idempotencyKey, which are common but still undocumented.

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

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

The description states a specific action ('Create') and resource ('fixed-asset category'), and goes further to explain what the category contains (defaults inherited by assets). This clearly distinguishes it from sibling tools like asset_category_update, asset_category_archive, and asset_category_list without ambiguity.

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

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

The description implies usage for creating a new category but does not explicitly contrast it with asset_category_update or state when not to use it. The context is clear, but no exclusions or alternatives are mentioned, so guidance is only implicit.

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

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

The annotation readOnlyHint=true already covers safety. The description adds one useful behavioral detail—'archived or not'—indicating the tool returns categories regardless of archive status. However, it omits error behavior, permission requirements, or response shape, so the added transparency is limited.

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 front-loads the verb and resource. It contains no filler, repetition, or superfluous details, making it efficient and immediately scannable.

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

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

For a simple read tool with two required parameters and a read-only annotation, the description is adequate but not complete. It does not mention what the response contains, what happens if the category is not found, or how to locate the ID, which an agent might need given the large sibling tool set.

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 0% schema description coverage, the description must compensate, but it only says 'by id,' which loosely maps to categoryId. It does not explain workspaceId, the relationship between the two parameters, or any format/constraints. This adds minimal meaning beyond the schema field names.

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 ('Read'), a specific resource ('fixed-asset category'), and a scoping constraint ('by id, archived or not'). This clearly distinguishes it from sibling tools like asset_category_list (listing) and asset_category_archive (mutation), making the purpose unambiguous.

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

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

The description implies the use case—fetching a single category when you have its ID—but does not explicitly mention alternatives or exclusions. An agent must infer that asset_category_list is for multiple categories and that create/update/archive are for mutations, as no routing 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, covering the safety profile. The description adds behavioral details: ordering by code, case-insensitive search over code and name, and acceptance of savedViewId (G00 saved-view seam). However, it does not disclose default behavior (e.g., whether archived items are included by default) or any pagination/limits, which are typical for list operations. With readOnlyHint covering mutation concerns, a 3 is appropriate—adds some value but not comprehensive.

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

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

Two sentences with no waste. The main action is front-loaded, and each clause adds a distinct piece of information (ordering, filters, search scope, savedViewId). The description is compact and well-structured.

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

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

For a read-only list tool with no output schema, the description covers the essential behavior: what is listed, ordering, filters, and the savedView seam. It lacks explicit mention of default filter behavior and pagination, but these are common patterns and the readOnlyHint already signals safety. Overall, the description is adequate for an agent to call this tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden. It explicitly explains all three optional parameters: 'active' (true = only live, false = only archived), 'search' (case-insensitive over code and name), and 'savedViewId' (G00 saved-view seam). The required workspaceId is self-evident from the context. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool lists workspace fixed-asset categories, ordered by code. It distinguishes itself from sibling tools like asset_category_create, asset_category_get, and asset_category_archive by specifying a list operation with ordering. The verb 'List' and resource 'fixed-asset categories' are explicit 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 implies when to use this tool: whenever a list of fixed-asset categories is needed, optionally filtered by active status or search. It does not explicitly name alternatives or when-not conditions, but the optional filters and mention of the savedViewId seam suggest clear use cases. The absence of explicit exclusions is a minor gap, but the context is sufficient for an agent to decide.

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

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

With readOnlyHint=true, the bar is lower. The description discloses what data is returned (depreciation trio, GL accounts, cost centre) and the refusal behavior for archived categories (category_archived). This adds useful context beyond the annotation and is consistent with 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 with no wasted words. The primary purpose is front-loaded, and the error case is appended succinctly. 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?

Since there is no output schema, the description properly explains the return content (the specific data fields) and the error condition. It asserts completeness ('FULL default set') and the goal of enabling asset creation without further questions, so nothing critical is missing for an agent to use this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'for a category' which implies categoryId, but does not explicitly define workspaceId or provide parameter-level detail. The two parameters are obvious from the tool name and context, but the description does not add much beyond what the schema names convey.

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

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

The description states a specific action: 'Resolve the FULL default set for a category' and enumerates exactly what is resolved (depreciation trio, GL accounts, cost centre). It also clarifies the purpose ('so an agent can create an asset (H01) with no further questions'), which clearly distinguishes it from asset_category_create/update/archive siblings.

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

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

The description implies when to use: when creating an asset, call this to obtain defaults. It also provides guidance on the archived-category error ('choose another or un-archive first'), which is a useful fallback. However, it does not explicitly mention alternatives or exclusions, though the use case is clear from the context.

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

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

No annotations are provided, so the description carries the burden. It discloses that validation is the same as create (account types, useful life, residual bounds), that code is immutable, and that only fields present in the patch change. This is meaningful behavioral context beyond the schema. It doesn't mention idempotency behavior or error cases, but the disclosed traits are significant.

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

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

Three sentences, each carrying distinct information: what the tool does, validation parity with create, and the patch semantics. No filler, no repetition of schema field names. The most important scoping information (patch object, immutable code) is front-loaded.

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

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

For a patch-update tool with no output schema, the description covers the key behavioral aspects: what changes, what doesn't, and what validation applies. It doesn't mention idempotencyKey usage or response format, but those are less critical for an update operation. The description is complete enough for an agent to invoke correctly, though it could note that idempotencyKey is required for retries.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'patch' object semantics (only fields present change) and mentions validation categories, but it doesn't describe individual parameters like workspaceId, categoryId, or idempotencyKey. The patch object's fields are self-explanatory from the schema, but the required parameters' roles are not explained. Baseline 3 is appropriate because the description adds some meaning (patch semantics) but doesn't fully compensate for the 0% coverage.

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

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

The description states a specific verb ('Edit'), a specific resource ('fixed-asset category'), and the mechanism ('through a patch object'). It also distinguishes itself from create by noting 'code is immutable through this verb' and that only fields present in patch change. This clearly differentiates it from sibling tools like asset_category_create and asset_category_archive.

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: when you need to edit an existing fixed-asset category, and it explicitly notes that code cannot be changed here (implying create is the place for that). It also states that only fields present in the patch change, which is a key usage guideline. However, it doesn't explicitly name alternatives or state when NOT to use it (e.g., use create for new categories, use archive for deletion).

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

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

With no annotations provided, the description carries the full behavioral burden and does so excellently. It states the draft status, immutability of the financial baseline after a posted acquisition, refusal of archived categories, number generation/uniqueness rules, and override behavior—far beyond a simple 'create' statement.

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

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

Four dense sentences, each earning its place: purpose/inheritance, required fields, overrides, numbering, error behavior, and lifecycle. Information is front-loaded and there is no filler or repetition.

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

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

For a 25-parameter creation tool with no output schema, the description is unusually complete: it covers required fields, defaults, overrides, error conditions, and post-creation lifecycle. It does not mention the return payload or explain idempotencyKey, which would have made it fully complete for an agent invoking a create 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 0%, so the description compensates by explaining the required fields, the Rappen unit and >0 constraint, the override list, and the optional number semantics. It leaves many optional parameters (e.g., locationId, serialNumber, idempotencyKey) undocumented, but the core creation-critical parameters receive meaningful semantic detail.

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

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

The description opens with a specific verb and resource: 'Create a capitalised fixed asset FROM a category (H00)', which clearly distinguishes it from related asset tools like asset_acquire or asset_update. It also explains the inheritance behavior that makes this tool unique among siblings.

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

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

The description gives clear context for when to use the tool: creation requires a category and only name, acquisitionDate and acquisitionCostRappen. It does not explicitly name alternatives or state when not to use it, but the category-based inheritance semantics strongly imply its intended use 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?

Beyond the readOnlyHint=true annotation, the description adds 'Writes nothing; deterministic for a given snapshot' and details error/warning behaviors (invalid_period_range, invalid_input, not_found, production_data_required). This goes well beyond the annotation's read-only hint and informs an agent of failure and warning 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?

The single dense paragraph carries no filler; every clause maps to a schema field, output field, or behavioral constraint. It front-loads the core purpose and consistency guarantee before diving into parameter semantics.

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 supplies a detailed return contract: ordered periods, totalAmountRappen, optional byGroup, totalProjectedRappen, assetsReachingResidual, and includeDetail per-asset detail. All 7 parameters and error modes are addressed, making the description sufficient for accurate 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 0%, so the description must compensate, and it does comprehensively: date format (YYYY-MM), month-window cap, reversed/over-long error code, allowed groupBy values, filter dimensions, includeDetail semantics, and unitsForecast relevance. This gives the agent far more than the schema names alone.

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: 'multi-period depreciation forecast' with identifiers H09, US-H09.2. It also differentiates itself from sibling asset_depreciation_preview and asset_depreciation_schedule by describing the multi-period window and the guarantee of consistency with the live schedule.

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 clear context by explicitly referencing the 'preview/schedule verbs' and positioning this as the multi-period forecast that reuses the same pure calculators. It does not explicitly enumerate when-not-to-use or name the alternative to use instead, so it falls just short of full routing guidance.

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

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

Beyond the readOnlyHint annotation, the description discloses meaningful behavior: output descriptor fields (labelKey, descriptionKey, requiresUnits, requiresRate, enabled, labelKey) and the effect of disabled methods on H00/H01 pickers. This meaningfully exceeds what the annotation already provides.

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

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

Four sentences, each contributing useful information: the resource, the method values, the descriptor fields, and the behavioral consequence of disabled flags. It is dense but not bloated, and the action is front-loaded.

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

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

With no output schema, the description compensates by naming all returned descriptor fields and the allowed method enum values. It also clarifies the read-only nature and the visibility behavior, which is enough for an agent to understand what it will receive and how to interpret it.

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

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

The single required parameter workspaceId is not explicitly documented; the description only indirectly refers to 'this workspace.' With 0% schema description coverage, some compensation is expected, but workspaceId is a simple required string and the schema property name is mostly self-explanatory. The description does not add much parameter-level detail, so 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 action ('List') and a clear resource: registered depreciation methods, and even enumerates the possible values: straight_line, declining_balance, units_of_production, none. It also identifies the returned descriptor fields, making it easy to distinguish this read-only listing tool from the sibling asset_depreciation_method_set_enabled.

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 useful context: each descriptor carries enabled flags and disabled methods are hidden from pickers, so an agent can infer this is the appropriate tool for inspecting available depreciation methods. It does not explicitly name alternatives like asset_depreciation_method_set_enabled or list when not to use it, but the context is clear enough.

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

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

With no annotations, the description carries the full burden and does so richly: it explains the absence-means-enabled semantics, that the operation only records a method switched off, that none can never be disabled and returns method_locked, that unknown methodKey returns unknown_method, and that the operation is idempotent. There is no contradiction with annotations.

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

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

Four dense sentences, each contributing distinct information, with the primary action front-loaded and edge cases packed efficiently afterward. There is no filler or repetition.

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

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

Despite having no annotations, no schema parameter descriptions, and no output schema, the description covers the purpose, scope, edge cases, error conditions, and idempotency behavior. This is enough for an agent to understand when and how to invoke the tool correctly.

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

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

The schema supplies only names and types, so the description compensates well by clarifying the enabled semantics, the methodKey edge cases, the workspace scope, and idempotency behavior. It does not fully specify every parameter detail, such as the exact idempotencyKey format, so a small gap remains.

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 action: enabling or disabling a depreciation method for a workspace, and frames it as a setup action. It also clarifies the key semantic that absence means enabled, so the tool can be distinguished from the many asset and valuation method tools in the sibling list.

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

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

Gives clear operational context: it is a setup action scoped to a workspace and is the toggle for depreciation methods. It does not explicitly name alternatives such as asset_depreciation_methods or the parallel inventory_valuation_method_set_enabled, so it stops short of explicit alternative routing.

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

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

Beyond the readOnlyHint annotation, the description discloses significant behavioral details: it returns a reason when the amount is zero with enumerated possible reasons, states that projectedNbvAfterRappen never goes below residual, describes the rejection of foreign/unknown assetIds with not_found, and explains the effect of proRata and override parameters. This adds rich 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 dense but well-organized: it starts with the core purpose, then return structure, side-effect guarantee, parameter details, and error handling. Every sentence adds value, and there is no fluff. It is a single paragraph but logically segmented, making it effective despite 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?

Given the complexity of 7 parameters, nested objects, and no output schema, the description covers return types, parameter semantics, error cases, and side-effect behavior. It provides enough detail for an agent to call the tool correctly without additional documentation, including the reason enums and the guarantee about NBV never going below residual.

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 0% schema description coverage, the description compensates by explaining most parameters: period format (YYYY-MM), assetIds (omission means all active), proRata (full_period or actual_days), unitsByAsset (mapping to units produced), and paramsByAsset (overrides for decliningRateBp and totalEstimatedUnits). However, daysByAsset is not explicitly described, and the exact structure of nested objects could be clearer, so it is not fully complete.

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

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

The description clearly states the tool's function: preview depreciation amount for a period, either for specific assetIds or all active assets. It specifies the verb 'preview' and the resource (depreciation amount), and distinguishes itself from posting tools by explicitly noting it writes nothing and creates no journal, which separates it from siblings like asset_depreciation_run_create.

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 implicitly guides usage by stating it is a read-only preview that creates no journal, implying it should be used when the agent wants to estimate depreciation without committing. It also explains the behavior when assetIds is omitted (covers all active assets). However, it does not explicitly name alternative tools for posting or other scenarios, so guidance is not fully explicit.

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

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

With zero annotations, the description carries the full burden and delivers richly: it discloses side effects (persists header and lines), non-effects ('Writes NO journal', 'Nothing is written in either case'), idempotency on both idempotencyKey and the (period, selection) signature, and the no-op empty outcome where 'NO run is persisted at all'. It even discloses state-transition behavior ('Once a period is POSTED its assets carry it as their last depreciation period') and error semantics (period_locked, run_already_exists, not_found §H-TENANT).

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?

Every sentence carries real operational meaning and the length is arguably justified by the tool's complexity (8 params, two filter modes, two granularities, many error codes). However, it is a single dense unbroken paragraph with no paragraph breaks or bullets, and there is some redundancy (the 'identical on every call' restatement of idempotency and the period-close checklist rationale). The size is appropriate; the structure is not.

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 8 parameters, no annotations, and no output schema, the description covers eligibility, filters, skipped-reporting semantics, granularity, error codes, idempotency, and empty-run behavior in exceptional depth. The remaining gaps are the explicit success-case return shape (only the empty response {ok:true, run:null, lines:[], empty:true, skipped:[...]} is fully spelled out) and the thin treatment of workspaceId's scoping. These are minor but real contract gaps given the absence of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate, and it does comprehensively: period is 'YYYY-MM'; unitsByAsset is defined as whole units produced with 'non-negative safe integers up to 1e12' and validation consequences; postingGranularity is explained as detailed vs summarised with sub-ledger implications; idempotencyKey's role is described; and assetIds/categoryId/costCenterId are identified as narrowing filters with distinct skipped-reporting semantics. Only workspaceId's tenant-scoping is left to the §H-TENANT cross-reference.

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 ('Create a DRAFT depreciation run for a period (H04)') and states exactly what is persisted: a run header with status=draft plus one line per asset with amount > 0. It also distinguishes itself from its closest siblings by noting 'Writes NO journal (the post verb does)' and referencing asset_depreciation_preview for the unitsByAsset shape. An agent can unambiguously separate this from run_post, run_reverse, run_get, and preview.

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 draft-vs-post lifecycle is explicit ('so a bookkeeper can review the proposed expense before anything hits the books'; 'the post verb does'), which tells the agent when to call this tool versus asset_depreciation_run_post, and the full eligibility criteria define when a create is meaningful. However, there is no explicit 'use X instead when you don't want to persist' statement; the preview alternative is only implied via the shape reference.

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 annotation readOnlyHint=true already marks this as read-only, and the description reinforces this with 'Read'. More importantly, it goes beyond the annotation by detailing the exact data payload (header fields, line fields, ordering) and disclosing a specific error condition (foreign runId returns not_found). This is valuable behavioral transparency that helps the agent set 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 long but well-structured: it leads with the primary purpose, then itemizes header fields, then line fields, and ends with a tenant-specific note. Every sentence adds information, and the format is easy to scan. It is not overly verbose given the amount of detail needed to enumerate the response.

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 must stand alone in explaining what the tool returns. It does so exhaustively, listing all header and line attributes including nested items like GL account ids and unitsProduced. It also covers edge cases (reversing link, foreign runId). Given the tool's complexity, the description is remarkably 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?

With 0% schema description coverage, the description carries the burden. It implicitly links runId to the id being read and mentions 'foreign runId' which clarifies scope. The workspaceId is not elaborated, but the tenant note implies it's the tenant context. It does not explicitly map each parameter, but it provides enough to understand their roles in this context.

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

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

The description opens with a specific verb ('Read'), a clear resource ('one depreciation run by id'), and an explicit objective. It enumerates exactly what will be returned (header fields plus every line with all fields), leaving no ambiguity about the tool's function. It is distinct from sibling tools like asset_depreciation_run_list or create because 'Read' implies a singular fetch by id.

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

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

The description clearly implies usage when the agent has a specific runId and needs the full detail of a single run. It does not explicitly name alternatives or state when not to use it, but the verb and resource make the intent unambiguous. Given the large sibling set, an explicit cross-reference to list or create would elevate it, but the current text suffices.

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 readOnlyHint annotation already marks the tool safe, and the description reinforces it with 'Read-only.' Beyond the annotation, it adds behavioral specifics: ordering newest first, exact period format, and allowed status values. It does not mention pagination or response shape, but the added context meaningfully exceeds 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?

Two compact sentences with no filler. The primary purpose is front-loaded, followed by the optional filters and a closing read-only note. Every sentence contributes information.

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

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

The description covers the essential selection context: what is listed, ordering, filters, and status vocabulary. Since there is no output schema, the agent still lacks guidance on returned fields, pagination, or response structure, which is a meaningful gap for a list endpoint.

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 0% schema description coverage, the description must carry parameter meaning. It does explain period format, status values, and the from/to window. However, it leaves workspaceId implicit and does not define the exact format or inclusivity of the from/to endpoints, so coverage is useful but incomplete.

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

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

The description states a specific verb ('List'), a precise resource ('workspace depreciation runs (H04)'), and an ordering guarantee ('newest period first'). This clearly distinguishes it from sibling tools like asset_depreciation_run_get or asset_depreciation_run_create by establishing that this is the read-only list operation.

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

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

The description communicates clear context: list runs for a workspace, optionally filtered by period, status, and date window. However, it does not explicitly say when to prefer this over closely related siblings such as asset_depreciation_run_get (single run retrieval) or asset_depreciation_preview/schedule (projections), leaving the selection partly implicit.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It fully covers atomicity, the nested steps (journal posting, asset_transaction writes, ledger updates), idempotency (no double-counting), date constraints, and all failure modes with specific reasons (stale_draft, period_locked, run_reversed). This is exemplary transparency for a complex mutation.

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 lengthy but every sentence adds value. It front-loads the core purpose and then details behaviors and errors. It could be tightened slightly (e.g., merging some redundant phrases like 'a double-post never double-counts' repeated), but overall it is well-organized and efficiently communicates a high-complexity operation.

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 annotations, no output schema, and sparse schema, this description is remarkably complete. It covers side effects, error conditions with reasons, idempotency, tenant scoping, and date semantics. An agent has all necessary information to call the tool correctly and interpret failures, which is exceptional given the operation's 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?

With 0% schema parameter descriptions, the description must compensate. It extensively explains postingDate (defaults, late-close rules, constraints vs acquisition date) and mentions idempotencyKey in the idempotency context. It does not explicitly elaborate on workspaceId or runId, but these are self-evident from the tool name and usage, so the coverage is mostly adequate.

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+resource: 'Post a reviewed DRAFT depreciation run (H04)' and enumerates the full scope of what the operation does (re-validates eligibility, posts a balanced GL journal, writes asset_transaction rows, updates balances, marks the run posted). It also differentiates from sibling tools like asset_depreciation_run_reverse and asset_depreciation_run_create by framing itself as the post action on a reviewed draft.

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

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

The description clearly states the precondition (a reviewed DRAFT run) and enumerates refusal reasons and the instruction to 'recreate the run' for stale drafts. It does not explicitly name the create/reverse sibling tools as alternatives, but the context makes the intended use clear. The guidance is strong but not exhaustive about when to use this versus related tools.

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

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

With no annotations provided, the description carries the full burden and delivers richly: it discloses the A02 reverseEntry call, the compensating asset_transaction type, the exact asset fields restored, the audit constraint (§H-AUDIT), the default reverseDate behavior, the idempotency on idempotencyKey, tenant scoping (§H-TENANT), and the consequence. It even names the error cases and the blocking period behavior. This is far beyond what annotations would typically provide.

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

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

The description is dense and information-rich, with the core action front-loaded. Every sentence adds meaningful behavioral or constraint information. It loses one point because it is long and somewhat sprawling, mixing audit references, error cases, and consequences in a single paragraph; a structured breakdown would improve scannability. However, no sentence is wasted.

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

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

For a complex mutation tool with no annotations and no output schema, the description covers: what happens (reversing entry, compensating transaction, asset restoration), the constraints (date, ordering, idempotency, tenant), the refusal conditions, and the post-condition (cannot re-post, new run allowed). An agent has everything needed to decide when to call it and what to expect. The only minor omission is the return value shape, but with no output schema the description still provides sufficient behavioral context.

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

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

Schema description coverage is 0%, so the description must compensate. It does: reverseDate semantics are fully explained (defaults to last day of period, may not predate first day), reason is described as recorded on the reversing entry and compensating transaction, and idempotencyKey is explained as making the operation idempotent. runId and workspaceId are not individually detailed, but their roles are clear from the context (foreign runId is not_found, workspaceId scopes the tenant). Minor gap: no explicit format for reverseDate, but the semantic guidance is strong.

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

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

The description opens with a specific verb ('Reverse a POSTED depreciation run (H04)') and names the exact resource and context. It distinguishes itself from sibling tools like asset_depreciation_run_post and asset_depreciation_run_create by stating it reverses a posted run, and it explicitly contrasts with the generic reverse_entry sibling by describing the compensating asset_transaction and asset state restoration. The scope is unambiguous.

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

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

The description explicitly states when to use it ('when a material error is found'), and provides clear exclusions: refused with run_not_posted, already_reversed, period_locked, and later_run_exists. It also states the ordering constraint ('runs are reversed newest first') and that a reversed run cannot be re-posted. This is explicit when/when-not guidance with named alternatives implied by the sibling list.

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

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

Beyond the readOnlyHint annotation, the description explicitly says 'Writes nothing' and details edge-case behavior: the final line residual-adjusts to match cost minus residual, units_of_production assets require a unitsForecast or return an incomplete projection with a warning, and a foreign assetId yields a not_found error. This is rich behavioral disclosure that far exceeds the annotation's minimal signal.

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 dense yet efficient, with every sentence contributing distinct value: purpose, output shape, residual behavior, units_of_production caveat, and safety/error semantics. It is front-loaded with the core action and remains readable without unnecessary jargon.

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 and 0% param coverage, the description provides a complete-enough contract: return row fields, residual adjustment guarantee, unitsForecast requirement, and error code reference. It leaves little ambiguous for an agent deciding whether and how to call this tool.

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

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

With 0% schema description coverage, the description compensates well by explaining fromPeriod's format and inclusivity, toPeriod as optional, and unitsForecast's required shape for units_of_production assets. It does not explain proRata or params, but the most critical parameters are semantically defined in plain language, which is a strong addition given the schema is silent.

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: 'Project the full remaining depreciation schedule for ONE asset', and immediately distinguishes itself from the sibling preview tool by noting it uses 'the same pure engine as the preview so a line never disagrees with a live preview'. This makes the tool's purpose unmistakable and separates it from asset_depreciation_forecast or asset_depreciation_preview.

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

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

The description gives clear context: it projects the full remaining schedule for one asset over a date range, and explicitly ties its behavior to the preview engine for consistency. It does not name alternatives or state when not to use it, but the scoping to 'ONE asset' and the optional toPeriod strongly imply when this tool is appropriate vs. other asset tools.

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

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

The readOnlyHint annotation already covers non-mutation. The description adds meaningful behavior beyond that: not_found on invalid ids, cross-tenant concern (§H-TENANT), and the fact that the returned data includes the posted GL journal entry.

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

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

Two dense sentences with no filler. The purpose is front-loaded, then the error/scope constraint is added precisely. Every clause earns its place.

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

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

For a simple get-by-id with no output schema, the description states the return contains the posted GL journal entry and explains invalid-id behavior. It does not explicitly walk through workspaceId, but the tool is simple enough that the description is nearly 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?

With 0% schema description coverage, the description carries the burden and mostly succeeds: it explains transactionId must name a disposal-type asset_transaction and what happens with foreign or wrong-typed ids. workspaceId is only implied as the workspace scope via 'in this workspace', which is useful but less explicit.

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 ('Read'), a specific resource ('fixed-asset DISPOSAL sub-ledger transaction by id (H06)'), and the key return content ('balanced GL journal entry'). The 'DISPOSAL' qualifier clearly differentiates it from generic asset_transaction_get and from disposal preview/dispose verbs.

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

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

It gives explicit exclusion semantics: transactionId must be a disposal-type asset_transaction, and foreign or acquisition/depreciation ids return not_found rather than leaking the wrong event. This tells an agent when not to use the tool, though it does not name a specific alternative 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 provide readOnlyHint=true, so the description's emphasis on 'WITHOUT posting anything' and 'Pure read' aligns with that. It goes beyond annotations by detailing what the tool does NOT do (does not check period lock) and what it returns (detailed journal lines). This adds context about execution behavior and side-effect absence, which is valuable. However, it could have also disclosed potential performance or rate-limit traits, but that's not critical.

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

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

The description is dense but well-structured, front-loading the core purpose and key constraints, then detailing the return value and refusal reasons. Each sentence adds critical information with no fluff. It's longer than average, but every clause earns its place given the complexity of the disposal logic.

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

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

Given the complexity of asset disposal (multiple accounts, conditional parameters, validation rules), the description is comprehensive. It explains what the tool returns, how the journal lines are constructed, and all refusal scenarios. The only minor gap is that it doesn't explicitly describe the output schema for the journal_lines structure (e.g., exact field names), but since there is no output schema defined and the description already provides a textual breakdown, it is sufficiently complete for an agent to understand the result.

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

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

Schema description coverage is 0% in structured form, so the description compensates by explaining each key parameter's role, especially the nuanced validation (proceedsRappen >= 0, gainLossAccountId type, proceedsAccountId conditional). It clarifies the purpose of optional fields like notes/reason/counterpartyName implicitly by listing them in the schema, but the description adds meaningful context for the core parameters. It does not detail every parameter but covers the ones essential for correct invocation.

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

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

The description explicitly states the tool's purpose: to preview the disposal journal for an asset without posting. It specifies the exact resource (fixed asset H06), the action (preview), and distinguishes it from the posting tool. It names the key output elements (lines, gain/loss calculation) and explains the 'same lines' guarantee, which is clear and non-ambiguous.

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

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

The description clearly states when to use this tool (to see what a disposal would book before posting, especially if period lock is unknown) and contrasts it with asset_dispose. It also provides explicit conditions for required parameters (e.g., proceedsAccountId needed when proceeds > 0) and lists all refusal reasons, giving agents complete routing information.

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

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

Beyond the readOnlyHint annotation, the description adds valuable behavioral context: it is a 'pure read over the append-only sub-ledger', and it explicitly states that 'no disposals in range is an empty success, not an error'. It also explains the sign convention of gainLossRappen. This fully discloses behavior 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 dense but efficient. It front-loads the purpose, then lists output fields, footer totals, and filters in a logical flow. Every sentence adds necessary information without fluff. It is appropriately sized for the complexity of the 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?

Given the tool's complexity, zero schema description coverage, no output schema, and a large sibling list, the description covers all essential aspects: input parameters, output fields, footer totals, filtering options, empty result behavior, and read-only nature. An agent can call it correctly and interpret results without additional context.

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

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

With 0% schema coverage, the description fully compensates. It specifies date format (ISO YYYY-MM-DD) and inclusivity, explains the filter semantics (categoryIds, locationIds, case-insensitive reason substring), and clarifies the output fields. WorkspaceId is not described but is a common contextual parameter, likely understood from the environment.

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

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

The description states a specific verb (implied get), resource (disposal gain/loss pack), and scope (date range). It names the exact record set (H06 disposals) and lists output fields. This clearly distinguishes it from related tools like asset_disposal_get or asset_disposal_preview.

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

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

The description specifies the date range and optional filters, making the tool's use case clear. It does not explicitly name alternative tools or say when not to use it, but the context of a summary report over a range is evident from the wording. It lacks explicit exclusions but provides enough guidance.

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

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

With no annotations, the description carries full burden and does so richly: it specifies the atomic single GL journal posting with exact debit/credit flows, the append-only asset_transaction fields, the status flip, forced net_book_value to 0, permanent exclusion from depreciation, asset_update refusal, all error codes, correction path, and idempotency semantics. This goes far beyond any annotation could.

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

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

The description is long but earned: it uses a clear (a)/(b)/(c) enumeration of the atomic steps, states gain/loss sign, scrap rules, consequences, error codes, correction, and idempotency in organized order. The opening and final 'CONSEQUENCE' sentence overlap slightly, but for a tool with this complexity every sentence carries operational 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?

There is no output schema, so the description must define the return value, which it does: idempotent replay returns {asset, transaction, journalEntry, gainLossRappen}. It also covers all side effects, failure modes, and post-conditions, making the tool fully callable by an agent without needing additional documentation.

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

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

Schema description coverage is 0%, so the description must compensate. It does for the financial core: proceedsRappen sign convention, proceedsAccountId absence for scrap, gainLossAccountId behavior, idempotencyKey replay, and disposalDate's role in period_locked. Notes, reason, and counterpartyName are not explained, but they are peripheral compared to the accounting semantics that the description does add.

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

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

The description opens with a specific verb and resource: 'Dispose an active or fully_depreciated fixed asset (H06): the TERMINAL financial event (sale, scrap, donation, write-off, retirement).' It distinguishes this from siblings like asset_disposal_preview and asset_disposal_get by emphasizing terminality, so an agent can tell exactly what it does and how it differs without opening the schema.

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

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

The description gives clear context: it must be called on active or fully depreciated assets, is terminal, and correction is via reversal of the journal plus a compensating asset_transaction, never an un-dispose. It does not explicitly name alternative tools (e.g., asset_disposal_preview) for pre-checking, so no when-not-to-use guidance, but the context is unambiguous.

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

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

Beyond the readOnlyHint annotation, it explains that the tool projects active depreciable assets forward from the current period, filters by remaining life within a capped window, orders results soonest first, and writes nothing. This gives the agent a clear safety and behavior profile.

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

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

The description is front-loaded and dense with useful facts, with no filler. It is a long single sentence with some domain shorthand (H09, §H-TENANT) that adds context but could be slightly tightened for readability.

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 list/report tool with no output schema, it tells the caller exactly what comes back: current NBV, residual, remainingMonths, and next forecasted depreciation, plus ordering. The required parameter, status modes, and withinMonths cap are all covered, so no critical usage information is missing.

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

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

With 0% schema description coverage, the description carries the parameter explanation: it defines status values and withinMonths default/cap. It does not explicitly describe workspaceId semantics, but that parameter is self-evident and named as required in the schema.

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

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

The description names a specific resource (assets at or approaching end of life), states the supporting report codes H09/US-H09.8, and contrasts the approaching vs fully-depreciated views. This is enough to set it apart from generic asset listing tools such as asset_list or asset_depreciation_schedule.

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

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

It clearly explains the default mode, when to use status='fully_depreciated', and how withinMonths affects results. It gives clear context for using this tool, though it does not explicitly name sibling alternatives or exclusions, which keeps it from a 5.

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, so the description's 'Read' matches. It adds value by disclosing the specific return contents (resolved financial baseline, GL accounts, convenience columns), which is more than a generic read. It does not mention auth or rate limits, but for a read-only tool with the annotation, the bar is met.

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 efficient sentence that front-loads the purpose and then enumerates the return fields. No filler or redundancy. The trailing 'later specs maintain' is a minor artifact but does not detract.

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

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

For a simple read tool with two parameters, no output schema, and a readOnlyHint annotation, the description adequately covers what the agent needs: it states the resource, the identifier, and the contents of the response. It is missing nothing critical 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 0%, so the description must compensate. It clarifies that the tool fetches 'by id', implicitly mapping to assetId, but does not explain workspaceId at all. The parameter names are self-explanatory, but the description adds minimal semantic value beyond the schema for these two 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?

States a specific verb ('Read') and resource ('one fixed asset by id'), and lists the exact contents returned (financial baseline, three GL accounts, status, convenience columns). This clearly distinguishes it from siblings like asset_list (list all) and asset_search (filtered search) without needing to open their schemas.

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

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

Provides clear context: it is the tool for fetching a single fixed asset by its id. It does not explicitly mention alternatives or when not to use it, but the singular-by-id scope is unambiguous against the many asset-related siblings (asset_create, asset_update, asset_transaction_get, etc.).

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 readOnlyHint annotation, the description discloses meaningful behavior: disposed assets retain full history and are not purged, disposal rows reset running totals to zero, entries include the posted GL journal_entry_id, and a foreign assetId returns not_found. This is rich behavioral context not available anywhere else.

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 front-loaded with the core purpose, then lists event types, output fields, running-total semantics, disposal behavior, read-only status, and tenant behavior. Each sentence adds substantive value; there is no filler 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 read-only single-asset ledger tool with only two simple parameters and no output schema, the description provides enough detail to invoke it correctly: what events are included, ordering, exact fields, running totals, post-disposal behavior, and not_found semantics. Nothing essential is missing.

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

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

The schema provides no parameter descriptions, so the description carries the burden. It clarifies that assetId identifies one fixed asset and adds tenant/error semantics ('foreign assetId is not_found'), but workspaceId remains unexplained beyond its self-evident name. Partial compensation for the 0% 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 specifies a precise verb and resource: retrieving the complete chronological ledger for a single fixed asset. It enumerates the event types and fields returned, and the 'ONE fixed asset' scope clearly differentiates it from list-style siblings like asset_ledger_list or asset_transaction_list.

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

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

The description implies usage context through the output spec—use this when you need the full event ledger with running totals for one asset—but it does not explicitly state when to prefer it over alternatives such as asset_transaction_get or asset_get. No when-not-to-use guidance or alternative routing 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?

The annotation readOnlyHint=true already signals safety, and the description adds valuable behavioral context: it returns a flat list with no running balance, describes the response shape {items, total}, and mentions pagination defaults. No contradiction with annotations.

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

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

The description is dense but every sentence contributes: scope, filters, pagination, return shape, a caution about running balance, and read-only flag. It could be trimmed slightly but remains efficient 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.