Lovie Company Formation

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

The annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds little beyond the schema, mostly restating that it retrieves details, which provides minimal additional behavioral context.

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

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

The description is a single efficient sentence that front-loads the primary action and target resource. Every word contributes, with no filler or redundant restatement of the tool name.

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

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

For a simple single-ID read operation with rich annotations, full schema coverage, and an output schema, the description covers what the agent needs to invoke the tool correctly. It could add a nod to distinguishing it from list/account-detail siblings, but 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?

Schema description coverage is 100%, so the schema fully documents the single uuid 'id' parameter. The description merely echoes 'by ID' and adds no extra meaning about format, default behavior, or constraints beyond what the schema already conveys.

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

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

The description states a specific verb ('retrieves'), resource ('a single account'), and identification method ('by ID'), making the core purpose clear. It implicitly distinguishes itself from list-style siblings but does not name a specific alternative, so it stops short of full sibling differentiation.

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

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

The description implies the tool is for fetching exactly one account by its ID, which guides basic usage. However, it gives no explicit guidance on when to prefer this over sibling tools such as account_get_list_account_details or list_accounts, nor does it state any exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a useful behavioral trait beyond the schema: batched retrieval that avoids N+1 calls. It does not mention pagination behavior, but that is less critical given the output schema and read-only 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?

A single, focused sentence that front-loads the core operation and adds a parenthetical efficiency note. There is no filler or redundant restatement of the schema.

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

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

The description conveys the batch purpose and the annotations/output schema cover safety and return shape. However, all three parameters are undocumented in prose and schema, including the nested filter object, so an agent may not know how to construct a valid request without inferring from schema property names alone.

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

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

Schema description coverage is 0%, and the tool description provides no parameter-level guidance. It does not explain the filter.accountIds structure, pageSize semantics, or pageToken usage. With such low schema coverage, the description needed to compensate for these gaps and did 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 uses a specific verb ('retrieves') and object ('account details') and clearly identifies that this is the batch variant, distinguishing it from the singular GetAccount-style sibling (account_get_account). The phrase 'eliminates N+1 GetAccount calls' makes the scope and intent immediately 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?

The description gives a clear usage justification: use this when you need account details in bulk and want to avoid repeated single-account calls. It does not explicitly name the alternative tool or state when not to use it, but the batch-vs-single distinction is enough 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 description adds important behavioral context beyond the annotations, including that confirmations are written as 'a user override that AI enrichment never overwrites' (a durable persistence guarantee) and that unresolvable transactions return in failures. It also explains the state transition. Since the annotations already cover idempotency and non-destructiveness, these added details are valuable and not redundant.

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 fluff: the first states the core action and scope, the second explains the durable override behavior, and the third provides failure handling and the alternative tool. The most important information is front-loaded, and every sentence earns its place.

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

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

For a batch operation in a complex review flow, the description is sufficiently complete. It describes the action, state transition, behavioral guarantee (override not overwritten), failure mode, and the correct alternate path. The output schema and idempotentHint annotation cover return shape and retry safety, so no critical 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?

The description partially clarifies the parameters: 'up to 500 transactions' maps to the transactionIds array with maxItems 500, and the phrase 'confirm the categories... for transactions' implicitly describes the transactionIds purpose. However, it does not explain the companyId parameter, and with schema description coverage at 50%, the description does not fully compensate for both parameters. The schema wrapper descriptions hold some of the load, but extra param-level guidance would lift the score.

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

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

The description clearly identifies the verb ('confirm'), the resource ('categories the posting engine chose'), the scope ('up to 500 transactions'), and the state change ('moving them from the pending tab to posted'). It also differentiates the tool from transaction_categorize_transaction, which the agent is directed to for unresolvable categories.

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 a key exclusion condition: transactions with no resolved category cannot be confirmed and will be included in failures. It then names the alternative (transaction_categorize_transaction) and instructs the agent to use it first in those cases. This provides direct when-to-use and when-not-to-use guidance, with a clear alternative.

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

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

Beyond the idempotent and non-destructive hints, the description reveals major behavioral effects: excluding voids the transaction's journal entry, stops the posting engine from re-deriving it, and removes the amount from every report. It also discloses the batch size limit of 500, giving the agent meaningful operational context.

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

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

Three sentences with no filler. The core action and flag direction are front-loaded, followed by behavioral consequences and concrete use cases. 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?

With annotations covering idempotency and non-destructiveness, and an output schema present, the description supplies the crucial behavioral details, batch limit, and use cases. One minor ambiguity remains: the schema does not mark `transactionIds` as required even though the description implies transactions must be targeted.

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 low at 25%, and the description does add meaning for `excluded` (true/false) and `transactionIds` (up to 500 transactions). However, `companyId` and `reason` are left unexplained beyond their schema metadata, so the description only partially compensates for the coverage gap.

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

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

The description states a specific action—exclude up to 500 transactions or restore them—and names the exact boolean flag (`excluded=true/false`). It also clarifies the accounting consequence (voiding the journal entry and removing amounts from reports), which distinguishes it from related accounting mutation tools like deleting journal entries.

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?

Explicit use cases are provided: duplicates, personal spending on a business card, and transfers already recorded elsewhere. The reversible nature (put them back with `excluded=false`) is also clear, but the description does not name alternative tools or state when not to use this operation.

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

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

Annotations already indicate destructiveHint=true, but the description adds valuable behavioral details: 'Entries already posted for elapsed periods are kept' and 'Audit-logged.' These go beyond the annotation by clarifying what is not destroyed and that the action is recorded. This is consistent with the destructive hint.

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

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

The description is two concise sentences. The first sentence states the primary action and consequence, and the second adds important side effects. Every word earns its place, and the structure is front-loaded with the core purpose.

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

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

For a tool with two parameters and an output schema, the description covers the essential behavior and side effects, including what is retained and audit logging. It does not mention prerequisites or reversibility, but the presence of an output schema reduces the need to explain return values. Overall, it is sufficient for a cancellation operation.

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

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

The input schema describes both parameters only as 'UUID value wrapper,' which is minimal but still provides 100% coverage. The description does not elaborate on the parameters, but with full schema coverage, the baseline of 3 applies. No additional semantic value is added by the 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 clearly states 'Cancel an accrual schedule so no further periodic entries are generated.' This specifies the action (cancel), the resource (accrual schedule), and the primary effect (ceasing generation of periodic entries), distinguishing it from sibling tools like accounting_create_schedule and accounting_get_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?

The description implies usage when an accrual schedule should stop producing future entries, and it provides clear context without explicitly naming alternatives or exclusions. It does not mention when not to use it, such as for deleting already-posted entries, but the purpose is self-evident.

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

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

The annotations already supply openWorldHint=false, idempotentHint=true, destructiveHint=true, and the description goes well beyond them by explaining what the destructive and idempotent behaviors actually mean: writes inside the period are rejected, re-closing the same window is a no-op, multi-currency companies get one closing entry per currency, and every close is audit-logged. No contradictions with the annotations.

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

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

The description is front-loaded and dense without being bloated. Seven sentences each add a distinct fact: purpose, window lock, equity roll, non-overlap constraint, post-close write rejection, re-close idempotency, multi-currency behavior, and audit logging. No filler or redundancy; the structure supports easy scanning.

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 an output schema and strong annotations, the description covers nearly all key behavioral outcomes and side effects. The main remaining gap is that it does not explain the 'basis' parameter or clearly state whether start/end dates can be omitted; given that the schema also does not describe these (coverage 20%), an agent might need external information for a fully informed call. Overall it is still substantially 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 only 20%, and only companyId carries a description. The description does add useful meaning for start/end dates and granularity (window definition, month/quarter vs fiscal-year handling) and adds the multi-currency detail, but it does not address the 'basis' parameter or give direct guidance on the date range parameters beyond the window mention. This is partial compensation for low schema coverage, not full compensation.

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 ('Close an accounting period') and the resource, expands with a concrete definition: locks the date window, posts a balanced closing entry, and rolls net income into equity. It is immediately distinct from sibling tools like accounting_reopen_period and accounting_preview_close, giving the agent enough to select the right 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 makes the core purpose and main precondition clear: close a period only when it does not overlap an existing closed period, and be aware that closing rejects new writes inside the period. It does not explicitly name alternatives (e.g., accounting_preview_close for previewing) or state when not to use this tool, so it is not the full 5, but the context is strong enough for an agent to identify the right scenario.

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

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

Annotations already signal idempotent and non-destructive behavior, so the description is not required to restate those. It adds valuable behavioral context by revealing that omitting transactionId clears an existing match and that closed statements reject the call.

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 contain the core action, the alternative clearing mode, and the closed-statement constraint. No filler or redundant restatement of the title/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?

With an output schema and annotations covering idempotence/destructiveness, the description covers the essential behavior and constraints. It leaves minor gaps such as defining 'closed statement' or how to obtain lineId, but nothing critical for a competent agent 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?

Although every parameter has a schema description, they are all only 'UUID value wrapper,' so the free-text description must carry real meaning. It does: 'ledger transaction settles a bank-statement line' maps transactionId and lineId to their roles, and 'omitting the transaction' explains the optional parameter's clearing behavior.

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

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

Description uses a specific verb 'Record' and names the exact resource: a ledger transaction settling a bank-statement line. It also distinguishes this confirmation tool from suggestion siblings by covering both confirm and clear behaviors.

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 what the tool does and provides a concrete usage mode ('clear an existing match by omitting the transaction'), plus a refusal condition ('Refused once the statement is closed'). However, it never names any alternative sibling such as accounting_suggest_statement_matches, so an agent must infer when to choose this over 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?

The description explains the concrete mutation: the first entry is reposted and the counterpart is excluded to avoid double counting. This goes beyond the annotations by detailing exactly what the confirmation changes.

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

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

Two concise sentences, front-loaded with the core action and a clear explanation of the side effect. No 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?

Explains the core behavior and side effect, but does not mention what the counterpart status changes to, reversibility, or prerequisites. Relative to its siblings (suggest_transfer_pairs, unpair_transfer), it lacks workflow context.

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

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

The description clarifies that the first-named entry is the one reposted and the counterpart is excluded, adding meaning to the two entry IDs beyond their parameter names and type. This helps an agent pick which ID goes where.

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

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

The description clearly states the action (confirm) and the object (two journal entries as a transfer pair), then specifies outcomes (first entry reposted, counterpart excluded). This gives an agent an unambiguous understanding of what the tool accomplishes.

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 effect of confirming but provides no explicit guidance on when to use it relative to siblings like accounting_suggest_transfer_pairs or accounting_unpair_transfer. An agent must infer the workflow 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?

Beyond the annotations (openWorldHint=false, destructiveHint=false), the description reveals that the tool posts Dr/Cr entries, uses straight-line allocation with rounding on the final period, and leaves cash-basis reports unaffected. This is exactly the kind of side-effect context an agent needs for a mutation tool, though it omits reversibility/cancellation details.

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

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

Three sentences, front-loaded with the core purpose and no filler. Each sentence adds distinct value: what it does, how entries/splits work, and where to source required account IDs.

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 9-parameter tool with nested objects and an output schema, the description covers the essential decision points: use case, posting mechanics, rounding, chart-of-accounts source, and cash-basis impact. It is slightly incomplete only in not touching optional identifiers like sourceTransactionId or the date fields, but these are secondary to 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?

With only 44% schema description coverage, the description partially compensates by explaining totalAmount, periodCount, debit/credit GL account selection, and mapping examples to kind. However, it does not clarify startDate, currencyCode, companyId, or sourceTransactionId, so an agent would have to infer those from the schema or 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?

States a specific verb and resource—'Create an accrual schedule'—and enriches it with concrete use cases (prepaid amortization, deferred revenue, depreciation) and the key distinction that it creates accrual-only adjusting entries. This clearly separates it from the read/cancel/preview siblings in the tool list even without naming them.

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

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

The description gives clear when-to-use context: spreading a total amount across periods as accrual-only entries, with examples of common scenarios. It also steers the agent to accounting_get_chart_of_accounts for choosing GL account IDs. It does not explicitly list when-not-to-use or name alternative tools such as accounting_preview_schedule or accounting_cancel_schedule, but the intended usage is unambiguous 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?

The description goes far beyond the destructiveHint annotation by detailing exact behaviors: derived entries are recreated on next sync, manual overrides revert to automatic, standalone entries are voided (kept for audit, excluded from reports), and all outcomes are audit-logged. This rich behavioral context is not present in the annotations and adds significant value.

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

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

The description is concise yet comprehensive, with each sentence adding necessary detail. It is front-loaded with the core action, then breaks down outcomes in a structured, logical order, avoiding redundancy and fluff.

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

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

Given the tool's destructive nature and multiple behavioral branches, the description covers all essential context: when to use alternatives, what happens for each entry type, and audit implications. With an output schema present and rich annotations, the description is fully complete for an agent to understand the tool's effects.

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

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

The input schema covers 100% of parameters with descriptions, but those descriptions are generic ('UUID value wrapper') and add little semantic value. The tool description does not elaborate on the parameters beyond their names, so it does not improve on schema coverage. Baseline 3 applies due to high schema coverage.

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

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

The description opens with 'Delete or void a journal entry', using a specific verb and resource that clearly distinguishes it from sibling tools like accounting_upsert_journal_entry or accounting_get_journal_entry_by_transaction. It also explains the different deletion semantics (derived vs manual override vs standalone), further clarifying the tool's unique purpose.

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

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

The description explicitly states 'For entries tied to a transaction prefer re-categorizing the transaction (the entry re-derives)', providing a clear alternative and when to use it instead. It also outlines the consequences for each entry type, giving the agent situational guidance on when deletion is appropriate.

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

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

The read-only and non-destructive behavior is already declared in annotations, so the description adds value beyond them by explaining that net income is rolled into equity and the balance sheet always balances. It does not cover authorization or edge-case behavior, but for a simple read-only report this is sufficient.

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

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

Two concise sentences with no filler. The core output is front-loaded, and the useful balancing nuance is added immediately after, making the description easy to parse and act on.

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 purpose and key calculation behavior are covered, and an output schema likely documents return fields, so return-value explanation is not needed. However, the under-specified parameters—particularly basis and currencyCode—leave an agent without enough detail to confidently select parameter values.

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

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

Schema description coverage is only 25% (just a 'UUID value wrapper' note for companyId), and the description only hints at asOfDate via 'as of a date.' It does not explain the basis enum (accrual vs cash), currencyCode's role, or the default behavior when asOfDate is omitted. With low schema coverage, the description should carry more parameter meaning.

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

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

The description states a specific verb ('returns') and a precise resource: assets, liabilities, and equity balances as of a date. It also includes a distinguishing nuance—equity includes net income to date, so the sheet always balances—which separates it from period-based statements like the profit and loss report.

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 'as of a date' phrasing implies a point-in-time report, which offers some usage context. However, there is no explicit guidance on when to prefer this tool over siblings like accounting_get_trial_balance or accounting_get_profit_and_loss, nor any when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read-only' line merely restates that safety profile. It adds some value by disclosing the flat-list-with-parent-links shape and the requirement to build the tree client-side, but it does not cover other behaviors like whether inactive accounts appear by default.

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 the key format constraint ('flat list with parent links; build the tree client-side') front-loaded. The only waste is the 'Read-only' sentence, which duplicates the annotations, and the name-echoing opener 'GetChartOfAccounts returns'.

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

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

With an output schema present, the return structure is already covered, and the description adds the client-side tree-building nuance. However, the boolean parameter includeInactive semantics are unexplained, so an agent cannot know what the default output contains or how to filter it without out-of-band knowledge.

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 50% and the description adds no parameter information at all. The schema's companyId description ('UUID value wrapper') only describes the wrapper structure, not its source or semantics, and includeInactive is entirely undocumented. The description fails to compensate for the coverage gap.

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

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

The description states a specific verb and resource: it returns the company's chart of accounts. It also adds a distinguishing format detail (flat list with parent links, tree built client-side), which separates it from report siblings like accounting_get_balance_sheet or accounting_get_general_ledger, though it does not name them explicitly.

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

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

Usage is implied: call this when you need the chart of accounts in a flat, client-constructed hierarchy. However, there is no explicit when-not-to-use guidance or comparison against sibling account/ledger tools, so the agent must infer when this is the right choice.

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

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

The annotations already establish readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety semantics. It adds useful behavior context on its own by explaining that the balances are book-side values and that discrepancies are what reconciliation resolves, which helps an agent understand the meaning of the data without implying any write or mutation behavior.

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

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

The description is concise and front-loaded, with the core output in the first sentence and the reconciliation rationale in the second. The final 'Read-only.' is redundant with the readOnlyHint annotation, but it is a minor duplication rather than a structural problem.

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

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

Given the simple one-parameter input, available output schema, and read-only annotations, the description is nearly complete for agent invocation. It could be slightly more explicit about which 'account tools' to compare against, but the included context explains the purpose and the data shape well enough.

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

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

Schema description coverage is 100%: companyId is documented as a UUID value wrapper. The description does not add parameter-level detail, but with only one well-documented parameter this is acceptable and receives the baseline score for high schema coverage.

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

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

The description states the exact resource (bank accounts and cards), the data produced (book balance and count of posted entries), and the reconciliation context, which clearly separates it from sibling accounting tools like accounting_get_balance_sheet or accounting_get_general_ledger. It lacks an explicit verb such as 'retrieve' or 'list', but the intent is unmistakable from the first sentence.

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: use this tool to see book balances per bank account/card and compare them against the bank's own balance from account tools. It does not explicitly list when not to use it or name specific alternative tools, but the reconciliation workflow guidance is strong enough for an agent to select it appropriately.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description is not burdened with safety disclosure. It adds useful behavioral context: pagination ('pages through'), scoping to one account, restriction to posted lines, and inclusion of opening, running, and closing balances. No contradictions with annotations.

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

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

The description is a single front-loaded sentence plus a read-only tag. Every phrase adds meaning, with no filler or repetition of schema 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?

The description gives a strong high-level picture, and the output schema covers return values, but with 8 parameters and only 25% schema coverage, the missing semantics for filters, basis, currency, and pagination tokens leave meaningful gaps for an agent deciding how to construct a correct 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 only 25%, so the description needed to compensate, but it only indirectly maps to glAccountId ('one account') and does not explain basis, startDate/endDate, pageSize/pageToken, currencyCode, or the nested identifier wrappers. Most parameters remain semantically underdocumented.

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 ('pages through'), names the exact resource ('one account's posted lines'), and describes the output shape (opening, running, closing balances). This clearly distinguishes it from broader accounting report tools like trial balance, balance sheet, or journal entry listings.

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 by stating this is the per-account register for posted lines, so an agent can infer it is appropriate when detailed single-account ledger history is needed. It does not explicitly name alternatives or exclusion conditions, but the scope is clear enough to route usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context: the data is static per release and safe to cache, which goes beyond the annotations. It also clarifies the tool returns a pairing of account types to detail types, giving a behavioral understanding of the data shape. No contradiction with annotations.

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

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

Two sentences: the first explains the function and use case, the second adds cacheability and read-only confirmation. No redundant phrasing, and the most important info is front-loaded. Every sentence earns its place.

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

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

The tool has an output schema, so return values are defined elsewhere. The description covers the purpose, the static nature, and the specific use case. One parameter is documented in the schema. It's complete for a read-only catalog tool; no missing prerequisites or error conditions are critical to mention.

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

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

The single parameter companyId is fully described in the input schema as a 'UUID value wrapper' (100% schema coverage). The description adds no additional semantics about the parameter. Baseline of 3 is appropriate since the schema carries the burden.

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

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

The description states a specific verb (returns) and resource (every account type with detail types and classification). It clearly distinguishes this from the chart of accounts tool by focusing on the account type catalog needed for the New account panel's dependent selects. The purpose is 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 provides clear context: it's the data needed for the New account panel, and it's static per release with safe caching. However, it doesn't explicitly name alternatives or exclusion conditions, though the use case is well defined. This is better than implicit usage but lacks explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description correctly reinforces but does not need to re-establish safety. It adds useful behavioral context beyond annotations by noting the result is 'empty when none exists yet,' which is valuable for an agent interpreting the response.

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 that puts the core behavior first. 'Read-only' is redundant with the annotation but harmless. It is appropriately sized with no fluff.

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

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

With an output schema present, return-value structure does not need description-level detail. The empty-result behavior is covered, the annotations handle safety, and the two required parameters are clear. This is complete enough for a simple read-only lookup.

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

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

Schema description coverage is 100%, so the parameter wrappers are already documented. The description adds no param-specific detail beyond the general 'one transaction' framing, which is enough for a baseline but not additive.

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

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

The description states a specific verb and resource: 'returns the journal entry derived for one transaction.' The singular scope clearly differentiates it from list-style siblings like accounting_get_list_journal_entries, and the empty-case mention adds precision.

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 frames the tool as the single-transaction lookup ('for one transaction'), giving the agent enough context to select it over list operations. It does not explicitly name alternatives or exclusion conditions, but the intended use case is unmistakable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral context: it pages through the journal register, supports filters, and specifically notes the review queue filter. It doesn't mention pagination details like pageToken behavior or response shape, but the output schema exists and the description's 'pages through' implies pagination. 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 a single sentence that packs in the core behavior (paging through journal register), the key feature (filters), and a practical example (review queue filter). It's front-loaded with the verb and resource, and every word earns its place. No fluff 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 read-only list tool with an output schema, the description covers the essential behavior: pagination, filtering, and the review queue use case. It doesn't explain the filter object's fields in detail, but the schema provides the structure. The main gap is not naming sibling tools like accounting_get_list_review_items for comparison, but the description's review queue hint partially addresses this. Overall, an agent can call this tool correctly with the given information.

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

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

Schema description coverage is only 25%, so the description must compensate. The description mentions filters and the needs_review filter, which maps to the filter object's needsReview property, but it doesn't explain other parameters like pageSize, pageToken, or companyId. The schema itself has descriptions only for companyId ('UUID value wrapper'), leaving filter, pageSize, and pageToken undocumented. The description adds some meaning but doesn't fully compensate for the low 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 ('pages through') and resource ('journal register') with filters, and explicitly mentions the review queue filter. It distinguishes itself from related accounting tools like accounting_get_list_review_items by noting the review queue is filter{needs_review: true}, though it doesn't name that sibling directly. The title 'List Journal Entries' is clear, and the description adds the pagination and filtering behavior.

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

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

The description implies usage context: it's for paging through journal entries with filters, and the review queue is accessed via needs_review: true. It doesn't explicitly state when not to use it or name alternatives like accounting_get_list_review_items, but the filter hint provides practical guidance. The read-only annotation reinforces safe usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds behavioral context beyond that: pagination ('pages through') and ordering ('newest first'). This is useful for an agent deciding whether to page through results or handle response ordering.

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

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

Two short sentences, front-loaded with the core action and ordering. The 'Read-only' note is redundant with annotations but harmless. No wasted words.

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

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

With an output schema present and annotations covering safety, the description is minimally adequate. However, it leaves filter behavior and pagination parameters unaddressed, and an agent must infer their meaning from the schema alone. Gaps remain for 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 only 25% (companyId has a minimal 'UUID value wrapper' note). The description barely helps: 'a company's periods' hints at companyId, but pageSize, pageToken, and filter semantics are left entirely unexplained. The description does not compensate for the low schema coverage.

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

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

The description uses a specific verb ('pages through') and resource ('a company's periods'), and adds a clear ordering detail ('newest first'). It is easily distinguished from single-period retrieval (accounting_get_period) and mutating period tools (accounting_close_period, accounting_reopen_period).

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 listing context is clear, but there is no explicit guidance about when to choose this over accounting_get_period or other period-related tools. The name and sibling list imply the distinction, but no direct routing or exclusion is stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is already structured. The description adds contextual value by explaining what the three tabs mean and that it returns counters alongside the page, which is helpful. It does not disclose pagination limits, potential timeouts, or any edge-case semantics, but for a read-only list tool with these annotations this is acceptable and on par with the high anchor.

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 well structured: it starts with the core purpose, then defines the tabs, then the row contents, and ends with the counters. Every section adds value and no filler is present. It is somewhat long, but the content justifies the length and the top-loaded main purpose keeps it scannable.

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

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

Given that an output schema exists and that annotations cover the safety profile, this description is fairly complete for a list tool: it tells the agent what tabs exist, what each row carries, and that counters are returned. The only meaningful gap is no explicit differentiation with accounting_get_review_counts or the batch mutation siblings, but that is more of a usage-guidance issue than a completeness one.

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 low (25%), so the description carries extra weight, and it does explain the 'bucket' enum through the PENDING/POSTED/EXCLUDED tabs. It does not explicitly describe search, date filters, cardIds, accountIds, pageSize, or pageToken semantics beyond their obvious names, meaning an agent still must rely on parameter names for a good part of the input contract.

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 action ('List bank transactions awaiting review') and then breaks down the three review tabs (PENDING, POSTED, EXCLUDED), which gives an agent an exact sense of what this tool returns. The detail on row contents (counterparty, amount, category, account, confidence) distinguishes it from sibling list tools like accounting_get_list_journal_entries and accounting_get_list_statements.

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

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

The description implies when to use the tool (when you need to list or page through bank transactions across the three review states), but it never explicitly routes away from accounting_get_review_counts, accounting_batch_accept_review_items, or accounting_batch_set_excluded. The tab definitions make the listing use case clear, but no when/to/exclusion guidance is given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate safety. It adds some behavioral context by indicating pagination and company scope, but it does not disclose filter behavior, ordering, or iteration semantics beyond what the schema implies.

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

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

The description is very short and action-oriented, with no filler. The phrase 'GetListSchedules' is redundant with the tool name and reads like code rather than natural prose, but the overall structure is scannable and front-loaded.

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

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

The output schema covers return shape, and annotations cover safety, so the description does not need to explain those. However, it omits guidance on filtering by status, how pagination tokens work, and when this list should be used instead of fetching a single schedule. It is adequate but has clear gaps.

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

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

Schema description coverage is only 25%, with only companyId described as a 'UUID value wrapper.' The description adds minimal parameter meaning beyond the word 'pages through,' which hints at pageSize/pageToken but does not explain filter.statuses, required parameters, or pagination conventions. The schema helps via enums and bounds, but the description does not compensate for the low 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 clear verb ('pages through') and resource ('a company's schedules'), making the tool's function obvious. It does not explicitly differentiate from accounting_get_schedule or other schedule-related siblings, but the plural list semantics are reasonably clear from the name and description.

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 accounting_get_schedule, accounting_create_schedule, or accounting_cancel_schedule. The only hint is the pagination framing, which implies a list operation, but no alternatives or conditions are stated.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Read-only.' It adds useful behavioral context beyond annotations: results are ordered 'newest period first' and include unmatched line counts per statement. It does not cover pagination or limits, but the output schema and low complexity reduce the need.

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, front-loads the verb and resource, and packs ordering and unmatched-count behavior without redundancy. 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 read-only list operation with an output schema and safety annotations, the description is largely complete. It conveys what is listed, the ordering, and the key metric, though it could strengthen context by mentioning the optional accountId filter or routing to the singular get_statement tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even without extra parameter explanation. The description adds no parameter-specific meaning, and the schema only describes each parameter as 'UUID value wrapper,' leaving the role of optional accountId implicit.

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

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

The description clearly states the action ('List'), the resource ('bank statements imported for reconciliation'), and adds meaningful specifics: newest period first and unmatched line counts. This distinguishes it from nearby siblings like accounting_get_statement and accounting_get_list_journal_entries.

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

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

The description implies its use case: when you need an overview of imported bank statements and their reconciliation progress. However, it does not explicitly name alternatives or state when not to use it, such as when a single statement's full detail is needed via accounting_get_statement.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the phrase 'Read-only' adds no new safety information. The description does add a useful behavioral constraint—only closed periods are returned—but it gives no further context about missing periods, auth requirements, or error behavior. With annotations present, this is adequate but not rich.

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

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

The core information is front-loaded in one clear sentence: 'returns one closed period by id.' The second sentence, 'Read-only,' repeats the annotation, and the description begins with the tool name, which prevents a 5, but there is no unnecessary 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?

For a simple two-parameter get-by-id tool with an output schema and read-only annotations, the description supplies the essential selection constraint (closed period) and is sufficient for calling the tool. It could add more context about when to prefer it over the list-periods tool, but that gap is largely an usage-guidance issue.

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

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

Schema description coverage is 100%, so the schema already documents the UUID wrapper shapes for companyId and periodId. The phrase 'by id' loosely maps to periodId, but the description does not add additional meaning beyond what the input schema and parameter names already 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 operation: 'returns one closed period by id,' with a clear resource (closed period) and identifier. This distinguishes it from siblings like accounting_get_list_periods, which retrieves multiple periods, and from write tools like accounting_reopen_period.

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

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

The description implies the tool is for fetching a single closed period by id, but it does not explicitly state when to use it over accounting_get_list_periods or mention exclusions such as open periods. There is no guidance about alternatives or prerequisites beyond the tool name and schema.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description explicitly repeats 'Read-only,' which is consistent. It adds some extra context about the report contents (revenue and expense accounts with activity, totals, and net income, but it does not disclose behavior around basis defaults, date inclusivity, or what happens when optional date parameters are omitted.

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

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

The description is short and front-loaded, with the main verb and resource in the first sentence. It is not an under-specified tautology, and every sentence contributes something. However, the 'Read-only' sentence is redundant with the readOnlyHint annotation.

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 five parameters, sparse schema coverage, and a nested companyId object, the description is not complete enough to help an agent correctly choose and populate parameters. The presence of an output schema covers return shape, but the description still omits how reporting basis, currency, and date ranges work, which is material for invoking an accounting report 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 only 20%, so the description must compensate, but it does not. It says the report is 'for a period,' hinting at startDate/endDate, but it never explains basis, currencyCode, companyId, or date semantics. The schema's enum for REPORT_BASIS_ACCRUAL vs REPORT_BASIS_CASH is left entirely unexplained for the agent.

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

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

The description clearly states the tool returns the income statement (profit and loss report) for a period, including revenue and expense accounts, activity, totals, and net income. This is specific enough to identify the resource, though it does not explicitly distinguish it from similar accounting report tools like accounting_get_balance_sheet or accounting_get_general_ledger.

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

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

The description offers no guidance on when to use this tool versus siblings such as accounting_get_balance_sheet, accounting_get_trial_balance, or accounting_get_general_ledger. It implies the tool is for P&L reporting by calling it an income statement, but there are no stated conditions, exclusions, or alternative recommendations.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying that the tool only returns counts and does not fetch rows, which prevents agents from expecting detailed transaction data. It also clarifies the grouping (pending/posted/excluded), beyond what annotations provide.

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

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

The description is two sentences, with the core action and scope front-loaded in the first sentence and the use case in the second. There is no wasted wording, filler, or repetition of the tool name, 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?

The tool is low-risk (read-only), has a single well-described parameter, and has an output schema, so the description need not explain return values. The stated grouping and 'without fetching rows' fully capture the relevant behavior, and the use case informs the agent what the counts are for. Nothing essential for correct invocation 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 coverage is 100% for the single parameter, and the schema describes companyId as a UUID value wrapper. The description adds no extra semantic detail about companyId, which is acceptable because the schema already fully documents the required input. This matches the baseline for high schema coverage.

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

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

The description uses a specific verb ('Count') and resource ('bank transactions per bookkeeping review tab'), names the three statuses (pending, posted, excluded), and explicitly notes that it does this 'without fetching rows.' This distinguishes it from row-returning siblings like accounting_get_list_review_items, so an agent can identify it correctly without opening 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?

The description states a clear usage context ('Use to report how much review work is outstanding') and implies an alternative by saying 'without fetching rows.' However, it does not explicitly name the alternative tool or state when not to use it, so it stops short of full when/when-not guidance.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the description's 'Read-only' is redundant. It adds useful context by specifying that the result includes postings, which is not required by the schema. No contradictions with annotations; the additional behavioral detail is minimal but relevant.

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

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

The description is one concise sentence plus a redundant 'Read-only.' Every phrase is informative: it names the resource, scope, and included data. There is no waste, and the key information is front-loaded.

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

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

For a read-only operation with two self-explanatory parameters and an existing output schema, the description covers the essential behavior: what is returned (one schedule with postings) and its safety (read-only, also in annotations). Details like error handling or prerequisites are not necessary for correct invocation given the annotations and schema.

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

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

Schema coverage is 100%: both parameters (companyId and scheduleId) are described as UUID value wrappers, which adequately defines their structure. The description adds no extra semantics about parameter meaning or usage. With full schema coverage, baseline 3 is appropriate.

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

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

The description is clear and unambiguous: 'GetSchedule returns one schedule with its postings.' It specifies the verb (Get), resource (schedule), and scope (one schedule), which distinguishes it from list-type tools like accounting_get_list_schedules. The phrase 'with its postings' adds useful detail not obvious from the name.

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 states what the tool does but does not provide explicit when-to-use guidance or name alternatives. The distinction from accounting_get_list_schedules is implied by the tool name and the singular 'one schedule,' but the agent must infer when to choose this over siblings. No exclusions or context are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the operational safety profile is covered. The description's 'Read-only' merely repeats the annotation, but 'with its lines and their matches' adds useful context about what the response contains. No additional behavioral details such as error conditions, company scoping, or output shape are disclosed.

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

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

The description is extremely compact: two short sentences, front-loaded with the core meaning and ending with the read-only qualifier. Every word earns its place, and there is no redundant filler or restating of the schema.

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

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

For a simple read-only retrieval tool with two required UUID parameters, an output schema, and robust annotations, the description is nearly sufficient. It states the single-statement scope and what is included (lines and matches). The only missing contextual element is explicit routing to list-oriented siblings, but that is more of a usage-guidance refinement than a completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter information. Both parameters are documented only as 'UUID value wrapper,' which is formal but not semantically rich; parameter names statementId and companyId carry the actual meaning. The description neither compensates for nor worsens this situation.

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

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

The description clearly identifies the resource as a single statement and specifies that it includes lines and their matches, which distinguishes it from listing tools like accounting_get_list_statements. The verb is only implicit through the title 'Get Statement,' but the scope and content are unambiguous. It could be stronger by explicitly contrasting with sibling getters, so it does not quite reach a 5.

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

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

The word 'One' implies this tool is for retrieving a specific statement rather than listing statements, giving minimal usage context. However, it does not explicitly state when to prefer this over accounting_get_list_statements or other statement-related tools. Usage guidance is present only by implication, not by explicit exclusions or alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the 'Read-only' statement mostly repeats structured data. The description does add useful context about what is returned (debit/credit totals per account) and the balancing property, but it does not discuss behavior like defaults, date-range handling, or how output is structured beyond the existing output schema.

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

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

The description is two short sentences with no filler. The core operation is front-loaded, and the balancing note is a useful, compact addition. Every sentence earns its place.

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

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

The tool is a read-only accounting report with an output schema and safety annotations, so it does not need to explain return values or destructive effects. However, given the low parameter coverage and the many sibling accounting tools, the description leaves the basis/date semantics and report-selection criteria partly to inference. It is adequate but not fully complete.

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

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

Schema description coverage is only 20%, so the description needed to compensate for the five parameters, but it does not. It only refers vaguely to 'a period,' leaving startDate and endDate unexplained, and it does not clarify basis, currencyCode, or companyId semantics. The schema provides formats and an enum, but not enough meaning for an agent to confidently populate the parameters.

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

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

The description clearly states a specific verb and resource: it returns 'every account's debit and credit totals for a period.' It also adds the balancing condition, which helps define the trial balance concept. However, it does not explicitly differentiate this tool from sibling accounting reports like balance sheet or general ledger, so it stops short of a 5.

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

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

The phrase 'for a period' implies when this tool is appropriate, and 'Read-only' signals it is safe to call. Yet there is no explicit guidance on when to choose this over accounting_get_balance_sheet, accounting_get_general_ledger, or accounting_get_profit_and_loss, nor any exclusions. The usage context is clear but not fully specified.

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

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

Beyond the annotations, the description adds meaningful behavior: the log is append-only, results are newest-first, and entries capture who changed what and when. The 'Read-only' statement aligns with readOnlyHint=true, and there is no contradiction.

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

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

Two concise sentences with no filler. The core purpose, ordering, and filtering option are front-loaded, and every clause contributes to helping the agent invoke the tool correctly.

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 purpose, ordering, filtering, and read-only safety, while the presence of an output schema removes the need to describe return fields. It does not explicitly distinguish this from cap_table_list_cap_table_audit_events, but that is a minor usage nuance rather than a call-blocking gap.

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

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

The description adds real meaning to entityId by explaining it scopes to one record's history, which goes beyond the schema's 'UUID value wrapper.' However, it does not explain pageSize/pageToken pagination behavior or the required companyId, and schema coverage is only 50%, so compensation is 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?

Description names a specific verb ('pages through'), a clear resource ('append-only accounting audit log'), a defined scope ('across journal entries and the chart of accounts'), and a default order ('newest first'). This clearly distinguishes it from sibling accounting read tools like general ledger or balance sheet retrievals.

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 concrete usage context: read the audit log for change history, or filter by entity_id for a single record's history. It stops short of explicitly naming alternatives or when-not-to-use, but the intended use case 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?

Annotations already provide readOnlyHint=true and destructiveHint=false, but the description adds meaningful context: it explicitly says 'without writing anything,' explains that blockers mirror ClosePeriod's preconditions, and clarifies that a clean preview predicts the close will not be refused. This goes beyond the structured annotations.

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

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

The description is compact and front-loaded with the core computation and side-effect guarantee. The phrase 'what closing carries with it' is a little vague, but it is not redundant and the overall structure earns 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?

Behavior, side effects, and relationship to ClosePeriod are well covered, and an output schema exists so return values do not need repeating. However, the tool has five parameters and the description offers no guidance on how startDate, endDate, basis, or granularity affect the preview, leaving a meaningful gap 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 only 20%, with only companyId documented. The description does not explain basis, startDate, endDate, or granularity, so it does not compensate for the low schema coverage. The parameter names and enum values are somewhat self-evident, but the description itself adds no parameter-level 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 uses a specific verb ('computes') and identifies a precise resource: per-currency revenue/expense totals, net income a close would roll, and close blockers. It clearly distinguishes itself from accounting_close_period by stating it writes nothing, and from reporting tools by its focus on close preconditions.

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 positions this as a safe pre-close check: it reports blockers from ClosePeriod's refusals and states that a clean preview means the close won't be refused. It does not explicitly name accounting_close_period as the alternative, but the purpose and timing are 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?

Annotations already provide readOnlyHint=true and destructiveHint=false, so the description adds the 'straight-line per-period split' computation detail and 'without persisting anything', which are useful beyond the annotations. No contradiction exists; the description reinforces the read-only nature.

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

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

Two sentences, no filler, and the key information (non-persisting, read-only) is front-loaded. Every word earns its place, making it an exemplary concise 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?

Although the tool has an output schema (so return values are covered) and annotations handle safety, the description leaves startDate unexplained, which is a core input for a schedule preview. It also does not clarify whether startDate influences the split (e.g., determines the first period). This gap makes it incomplete for a 3-parameter tool.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It mentions 'given amount and period count' but completely omits startDate, leaving its purpose unclear. It also does not clarify that totalAmount is a string with decimal format, which is non-obvious. The description adds only partial meaning, failing to compensate 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 a specific verb (computes) and resource (straight-line per-period split) and explicitly notes it does not persist anything, distinguishing it from accounting_create_schedule and accounting_get_schedule. The read-only nature is also stated, making the tool's 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 implies when to use it ('without persisting anything' suggests preview before commit) but does not explicitly name alternatives or exclusion criteria. It conveys the context effectively, though it could be more direct about when not to use it (e.g., when you need to save).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds clarity that nothing is created until confirmation, but it does not describe any side effects or state changes, nor does it mention any potential data volume or latency. Given annotations cover the safety profile, this is adequate but not rich in behavioral context.

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

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

The description is a single, focused paragraph that front-loads the core purpose and the critical caveat (nothing is created until confirmation). It lists what the proposals include, which is useful for an agent deciding to use the tool. Every sentence carries relevant information with no fluff.

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

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

The tool has an output schema, so the description does not need to detail return values. It covers the key workflow (propose then create), the inputs (posted transactions), and the nature of the output (proposals with specific fields). The only minor gap is not detailing edge cases (e.g., no transactions found), but the output schema likely handles that. Overall, this is well-equipped for an agent.

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

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

The schema has only one parameter with 100% description coverage (the 'companyId' wrapper). The description does not add extra meaning to the parameter beyond what the schema states, so baseline 3 is appropriate. The description implicitly ties the parameter to the company being scanned, but no additional format or usage details are provided.

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 scans recent posted transactions and suggests accrual schedules, giving a specific example (amortize prepaid over 12 months). It differentiates itself from accounting_create_schedule by emphasizing that this tool only proposes, not creates. This distinguishes it from the sibling 'accounting_create_schedule' and 'accounting_preview_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?

The description explains the tool is a proposal generator and explicitly tells the agent to call accounting_create_schedule to confirm a proposal, which is clear guidance on the next step. It distinguishes from 'create' and 'preview' via the propose-only nature. However, it does not explicitly state when to avoid using this tool or mention alternative routes (e.g., manual creation) when proposals are not suitable.

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

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

The description adds meaningful detail beyond the destructiveHint annotation: it voids closing entries, lifts the write lock, allows editing, permits re-closing, and is audit-logged. This explains the consequences of the destructive action, increasing transparency. 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 a single, well-structured sentence that front-loads the core purpose ('Reopen a closed accounting period') and then provides essential details. Every word earns its place, with no fluff 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 destructive mutation with two parameters and an output schema, the description provides sufficient context: the scope, the side effects (voiding entries, lifting lock), and the audit trail. It does not mention prerequisites like period must be closed, but that is implied. Overall, it is fairly complete for the tool'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?

The input schema already documents both parameters (companyId and periodId) with full coverage, so the baseline is 3. The description does not add any additional semantics beyond what the schema provides, so it stays at baseline.

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

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

The description clearly states the tool's purpose: to reopen a closed accounting period by voiding its closing entries and lifting the write lock. This specific verb-resource combination distinguishes it from siblings like accounting_close_period (the inverse operation) and read-only period queries.

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 to use the tool: when a closed accounting period needs to be reopened so entries inside its date window can be edited. It implies the alternative of leaving the period closed and contrasts with close_period, though it does not explicitly mention when NOT to use it or list alternative tool names.

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 the key side effect not present in annotations: it posts exactly one journal entry against Opening Balance Equity, dated the day the books open. It also clarifies sign semantics (positive for an asset, negative for money owed). It stops short of explaining reversibility or idempotency, but it gives the critical behavioral context for a mutating call.

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 short sentences front-load the purpose and operational rule, with no filler or repetition. Every sentence adds value: what it does, what it posts, why it matters, and how to pass the amount.

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 solid for a small mutating tool and an output schema exists, so return format need not be described. The biggest completeness gap is the relationship between companyId, accountId, and cardId: the schema only marks companyId required, and the description never says the caller must also provide one of the account/card identifiers or what happens if both are supplied.

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

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

The description meaningfully clarifies the amount parameter (establish amount, not the difference, with sign conventions) and ties asOfDate to the day the books open. However, the schema's description coverage is low-quality ('UUID value wrapper'), and the description does not explicitly state that one of accountId or cardId is required alongside companyId, nor what companyId represents. It compensates only partially.

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

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

The description uses a specific verb and resource: it records the opening balance of a bank account or card and posts one journal entry against Opening Balance Equity. This is materially more precise than the title and distinguishes the tool from generic journal-entry or transaction-categorization 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 makes the intended context clear: use this when a bank account or card held money before the transaction feed's history begins, and it explicitly warns to pass the amount to establish rather than the difference. It does not name alternative tools or state when not to use them, but the context is strong 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?

Annotations already declare readOnlyHint=true and destructiveHint=false; the description reinforces this with 'Writes nothing.' It adds valuable behavioral detail on how matching works: exact amount requirement and ranking by date proximity and description. This goes beyond the structured annotations without contradicting them.

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

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

Two sentences, front-loaded with the core purpose, followed by ranking logic and side-effect guidance. Every clause adds information; there is no filler or repetition.

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

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

Complete for a read-only suggestion tool: purpose, matching criteria, side-effect profile, and the next-step sibling are all covered. The output schema handles return-value details, so nothing needed for invocation or correct use is missing.

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

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

Schema description coverage is 100%, with both parameters fully labeled as UUID value wrappers. The description does not add extra parameter-level context, but the schema already carries the burden, so the baseline score of 3 applies.

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

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

Description states a specific verb ('Rank') with a clear resource ('ledger transactions against a statement's unmatched lines') and defines the tool's exact job. It differentiates from the sibling confirm tool by explicitly saying it does not write and that confirmation happens elsewhere.

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

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

Description tells the agent when to use it: to rank candidates against unmatched lines before applying a match. It explicitly names the alternative follow-up tool, accounting_confirm_statement_match, and warns that this tool writes nothing, which prevents 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Writes nothing.' Beyond that, it transparently describes the ranking behavior and the exact criteria used to find matches, which is useful operational context not present in 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?

Two tight sentences with no filler. The core behavior is front-loaded, matching criteria follow, and the read-only caveat plus the follow-up tool are packed at the end without redundancy.

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

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

With an output schema present, annotations covering safety, and 100% schema coverage, the description covers everything an agent needs to call the tool correctly: what it returns conceptually, what criteria it applies, that it is non-mutating, and which sibling completes the workflow. 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?

Schema description coverage is 100%, and both parameters (companyId and journalEntryId) are adequately documented as UUID wrappers. The description does not add parameter-specific detail beyond those criteria, which is acceptable given the schema already carries the semantic weight.

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

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

The description names a specific verb and resource—'Rank the journal entries that could be the other half of a transfer'—and gives precise matching criteria: opposite direction, same amount, different instrument, dated within a few days. It also differentiates from the sibling accounting_confirm_transfer_pair by explicitly pointing to it for applying a suggestion.

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: to identify transfer-pair candidates. It also tells the agent that the tool writes nothing and that applying a suggestion should be done via accounting_confirm_transfer_pair, effectively naming the follow-up alternative. It stops short of listing explicit exclusion conditions or comparing against other accounting tools.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the description does not need to restate those. It does add that the operation reverses a confirmation and 're-derives both halves', which signals a state transition rather than a read. Still, it does not explain what happens to existing mirror entries or what 're-derived' means operationally.

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 the core action ('Undo a confirmation') front-loaded. It contains no filler or repetition. The second clause is terse to the point of being obscure, but it does not waste the agent's attention.

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?

An output schema exists and annotations cover idempotency and destructiveness, easing some burden. However, the description omits the precondition (a prior confirmed pairing), the concrete effect on the journal entry, and any pointer to the closely related confirm/suggest transfer siblings. An agent would still need significant domain knowledge to predict the result of calling this tool.

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

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

Schema coverage is 100%, and both companyId and journalEntryId have descriptions, though the descriptions only say 'UUID value wrapper.' The tool description adds no parameter-level meaning beyond the schema and the parameter names, so the high-coverage baseline of 3 applies.

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

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

The description states a specific action ('undo a confirmation') and the resource (a transfer pairing), and the title 'Unpair Transfer' reinforces this. It is implicitly contrasted with the sibling accounting_confirm_transfer_pair, so an agent can distinguish them. However, 'the mirror returns and both halves are re-derived' is metaphorical and leaves the exact scope of the undo 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?

No guidance is given about when to call this tool versus alternatives. It does not mention that it should be used after accounting_confirm_transfer_pair or describe the precondition that a pair has already been confirmed. The word 'undo' implies it is the inverse operation, but with many accounting siblings, an agent gets no explicit decision support.

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

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

Beyond the annotations (idempotentHint=true, destructiveHint=false), the description discloses the balancing invariant, the line-count and sign rules, that source and status are forced to source=user and status=POSTED regardless of input, that the entry is preserved across re-enrichment, and that every save is written to the audit log and created. None of this is stated in the annotations, so the description adds substantial behavioral context. No contradiction with the annotations.

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

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

Three dense sentences earning their keep: sentence 1 states the resource and use cases, sentence 2 states the validation constraints and data s, sentence 3 explains replacement, forced fields, and audit logging. The purpose is front-loaded and there is zero filler.

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

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

Despite having only one deeply nested parameter, the description covers the validation rules you need to conform to, the authoritative source for account IDs, the override behavior when transaction_id is supplied, and the server-side forced fields. An output schema exists, so return-value documentation is unnecessary. The only minor omission is the lack of guidance on what fields are required within an existing entry update, but 'UPSERT semantics

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 param-documentation burden and largely succeeds: it explains the balancing rule, the sign-side interpretation of amounts, the source of valid glAccountId values, the meaning of transactionId, and the forced status/source. Some secondary fields such as accountCode vs accountName, currencyCode, entryDate, and created/updated timestamp semantics remain undocumented in both the schema description and the tool 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 uses a specific verb-plus-resource ('Create or replace a double-entry journal entry') and immediately scopes it into two distinct use cases: manual adjustment or per-transaction override. This clearly distinguishes the tool from sibling read tools like accounting_get_list_journal_entries and from accounting_delete_journal_entry.

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

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

The description gives explicit when-to contexts: a manual adjustment or a per-transaction override, and explains that supplying transaction_id triggers replacement of a transaction's derived entry. It also instructs the caller to source glAccountId values from accounting_get_chart_of_accounts (postable only), naming the correct sibling. It does not explicitly state when not to use it or name write-alternatives, so it stops short of 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?

With only openWorldHint=false and destructiveHint=false in annotations, the description adds meaningful behavior: it explicitly says the aggregation happens at read time and creates no new storage. That is useful context beyond the annotations, though it does not cover permission or freshness details.

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

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

The description is two short sentences, with all information front-loaded. It wastes no words and packs the source, operation, output dimensions, and storage behavior into a compact form.

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 an output schema and three self-naming parameters, the description covers the key details: data source, grouping, metrics, and side-effect-free behavior. It is slightly incomplete only because it does not address parameter roles or when to prefer this tool over its close siblings.

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

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

Schema description coverage is 0%, and the description does not explain how companyId, periodStart, or periodEnd affect the aggregation. The parameter names and date patterns are self-explanatory, but the description adds no semantic detail such as inclusivity, defaults, or how the period maps to the monthly grouping.

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 operation (unions four ad platforms' daily tables at read time) and a concrete result (per-provider/month/currency spend/impressions/clicks/conversions plus CPA), which clearly identifies what the tool does. It does not explicitly name a sibling alternative, but the four-platform aggregation is enough to set it apart from the per-platform campaign-window 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?

No guidance is given on when to choose this tool over ads_insight_summarize_campaign_window or the per-platform metric tools. The read-time/no-storage note implies a safe aggregation use case, but it does not state prerequisites, exclusions, or alternatives.

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

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

Annotations only provide openWorldHint=false and destructiveHint=false. The description adds non-obvious behavioral context: results are cached per company + account + window + charge, and repeated panel opens do not re-run the agent. This is genuinely useful beyond the annotations and does not contradict them.

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

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

Two concise sentences with no filler. The core purpose and scoping constraints are front-loaded, and the caching behavior is a relevant secondary detail. 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 output schema and annotations cover return shape and safety profile, but the description omits usage routing versus sibling tools and leaves parameter semantics almost entirely to parameter names. With six optional parameters and zero schema descriptions, an agent cannot confidently construct a correct invocation.

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

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

Schema description coverage is 0% for six parameters. The description indirectly maps 'company + account + window + charge' to likely parameters, but it does not explain provider semantics, date formats, optionality, chargeAmount syntax, or what happens when parameters are omitted. It only partially compensates 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?

Description uses a specific verb ('summarises') and identifies the resource: one charge against the campaigns in its billing window. This is more specific than the title and implies a distinct role from the per-provider get_campaign_window siblings, though it does not explicitly name them.

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

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

No guidance on when to use this tool versus the closely related per-provider siblings (google_ads_metrics_get_google_ads_campaign_window, meta_ads_metrics_get_meta_ads_campaign_window, etc.). The caching note hints at a UI/panel context, but it never states selection conditions, exclusions, or alternatives.

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

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

Annotations only declare openWorldHint=false and destructiveHint=false, so the description carries the behavioral disclosure burden and it delivers: it discloses the push-notification side effect on the user's device, the required human approval step, session expiry in minutes, and single-use consumption. This is all context the annotations do not provide, and nothing in the description contradicts the annotations.

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

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

A single dense paragraph of roughly 60 words with the core purpose front-loaded before the workflow, lifecycle constraints, and sibling routing. Every clause earns its place — purpose, gated-tool examples, step sequence, expiry, and single-use — with no filler or restatement of the title.

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

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

An output schema exists, so return values need no explanation, and the description covers the what, when, and full follow-up workflow plus expiry and single-use semantics. Minor gaps remain: no polling cadence, no failure-handling guidance for user denial or mid-flow expiry, and 'minutes' is imprecise; but nothing essential to invoking the tool correctly 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 schema description coverage at only 17% (one of six parameters documented, and that one only as 'UUID value wrapper'), the description must compensate, and it does for two of six: 'create the session with the exact action_type and payload the tool documents' tells agents that actionType and actionPayload are not free-form but must mirror the gated tool's documented values. originLocation, originPlatform, actionDescription, and originTrustedDeviceId remain unexplained, with only a loose hint that the intended device is 'trusted.'

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

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

The description uses a specific verb and resource — 'Opens a sensitive-action approval on the user's own trusted device' — and explains the delivery mechanism (a push notification asking them to approve on their phone). It also differentiates itself from its only sibling, approval_session_get_approval_session_status, which the description explicitly names as the subsequent polling step.

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 the tool ('Use before tools that demand an approval') and names concrete gated tools: the domain auth-code reveal, the trademark firm handoff, and the ITIN submit. It then gives the full orchestration sequence — create the session, tell the user to check their phone, poll get-approval-session-status until APPROVED, pass the session id to the gated tool — leaving no ambiguity about the workflow.

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?

Consistent with the readOnly/destructive hints: it is a status-only poll and does not create a new approval session. However, it relies on the undefined term 'gated action' without explaining what that action is or what the returned status values look like. No mention of error cases or polling 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?

Extremely concise: three short sentences, front-loaded with the purpose, and scannable. No fluff or redundant restatement of the tool name.

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

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

Covers the core purpose and a key exclusion (does not create), but does not identify what 'the gated action' refers to, what the return payload includes, or when polling is appropriate. For a status-poll operation this is workable but under-specified.

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

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

The input schema already defines sessionId as a UUID wrapper; the description adds nothing about what the sessionId refers to or how to obtain it. It doesn't need much because the schema covers the type, but it also doesn't clarify the format of the sessionId within the outer object.

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 identifies a specific action (poll status) and resource (approval session), and explicitly clarifies it does not create a new session. However, the phrase 'for the gated action' is vague—it doesn't name which gated action or session it refers to, which could confuse an agent selecting this tool.

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

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

The description provides minimal usage guidance: it says it is a lightweight poll (status only) and that it does not create a new approval session. It does not name a sibling alternative explicitly (e.g., create_approval_session), nor does it specify when polling is appropriate or when to avoid it.

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

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

Beyond the annotations, the description discloses non-obvious behavior: it runs a 'four-check pipeline' and a 'per-agent autonomy fence,' and redirects out-of-envelope payments to human approval. This gives an agent useful insight into side effects and gating, though the pipeline steps and envelope criteria remain vague.

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-written sentences with no filler. The primary action is front-loaded, and the second sentence adds meaningful behavioral context without 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 4-parameter tool with no schema descriptions and substantial behavioral implications, the description is too thin. It omits parameter semantics, pipeline details, envelope determination, and what happens after human approval, leaving an agent to guess at critical invocation details.

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

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

Schema description coverage is 0%, so the description must compensate, but it only mentions a 'signed payment mandate' at a high level. It does not explain the role of jcsHash, how serviceLevel affects execution, what format mandateBodyJson should take, or what signatureB64url signs.

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 ('Submit'), a specific resource ('a signed payment mandate'), and a clear purpose ('autonomous execution'). This distinguishes it from drafting/confirming payment tools, though it does not explicitly name sibling alternatives.

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

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

The phrase 'for autonomous execution' implies the intended use case, and the autonomy fence comment clarifies when human approval is triggered. However, it does not explicitly state when to use this tool versus draft_payment, confirm_payment, or other payment-related alternatives, leaving the routing partially 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?

Annotations already mark the tool as idempotent and non-destructive; the description adds meaningful behavioral context by explaining the consequence of not using it (section held open, application blocked). This is valuable beyond the annotations, though it does not detail response behavior.

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

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

Two sentences with no filler. The first sentence states the core purpose, and the second provides the critical consequence. Every word earns its place.

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

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

The description adequately conveys the purpose and business impact, and the output schema covers return values. However, the meaning and optionality of fieldPath are left underspecified, which is important for an agent deciding whether and how to invoke the confirmation 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 only 50%, with fieldPath lacking any semantic description and applicationId only described as a 'UUID value wrapper.' The description does not compensate by explaining what fieldPath represents or how it relates to the extracted value being confirmed.

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 ('records') and resource ('that a human checked a read value'), and the title reinforces the extracted-value scope. It clearly separates this confirmation action from extraction and banking-application tools like banking_extract_document_fields.

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 explains when to call the tool: after a human checks a read value, particularly for low-confidence extractions that would otherwise block submission. It does not explicitly name alternatives or say when not to use it, but the context is strong enough 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?

With only openWorldHint: false and destructiveHint: false in annotations, the description carries the behavioral burden and delivers: it discloses the write is intention-only, that no funds are transferred by any part of Lovie today, and instructs the agent never to claim the deposit was sent. This goes well beyond what the annotations convey about side effects and user-facing truthfulness. No contradiction with annotations exists — a non-destructive, closed-world intent recording aligns with destructiveHint: false and openWorldHint: false.

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 the core purpose front-loaded in the first sentence. Each subsequent sentence earns its place by clarifying the non-transfer behavior and a critical communication constraint; 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?

The description fully covers what the tool does, what it does not do, and the key user-communication rule, and an output schema exists so return values need not be described. The main residual gap is the semantics and optionality of amount and currencyCode, which are not addressed in the description.

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

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

Schema description coverage is only 33%, and the sole parameter description is the thin 'UUID value wrapper' for applicationId. The tool description does not compensate: it never states that amount represents the deposit value, that it is actually optional despite only applicationId being required, or that currencyCode is an optional ISO code. An agent must infer the meaning of amount and currencyCode from pattern constraints 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 verb, 'Records,' and a specific resource, the opening deposit a founder chose for their banking application. It immediately clarifies scope by stating it 'stores an intention only' and that no money moves, which distinguishes it from the many money-movement siblings (commit_transfer, draft_payment, autonomous_pay).

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 sets clear context, indicating this is the step that records the founder's deposit choice as an intention, and explicitly states the tool does not move money. It lacks explicit naming of alternatives such as banking_get_initial_transfer_preview or commit_transfer, so guidance is contextual rather than directive. The 'Never tell the user their deposit has been sent' line adds a useful behavioral boundary.

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 meaningful behavior beyond the sparse annotations: it fills values with provenance ('marked with where it came from') and confidence, and it refuses to set industry classification. But 'fills in the values' is ambiguous about whether the tool persists changes directly or returns them for confirmation, and there is no mention of permissions, reversibility, or side effects. Given the annotations only contain destructiveHint=false and openWorldHint=false, the description does not fully carry the behavioral burden.

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

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

The description is two sentences with no filler. The first sentence front-loads the action and resource, then explains the output quality signals; the second sentence adds a crucial limitation. 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?

Given there is an output schema, the description need not explain return values. It covers the document types, the extraction-and-fill action, provenance/confidence, and the industry-classification limitation. The main gap is not clarifying whether the filled values are persisted immediately or require a subsequent confirmation step (suggested by sibling banking_confirm_extracted_value), but this is minor for a simple two-parameter tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description provides no parameter-specific information. Both parameters are documented only as 'UUID value wrapper,' which is minimally helpful, but their names (applicationId, documentId) make their roles self-evident. The description adds no further semantic meaning to the parameters.

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

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

The description states a specific verb ('Reads ... and fills in'), a clear resource ('uploaded document on a banking application'), and enumerates the accepted document types ('Certificate of Incorporation or an IRS EIN letter'). It also explicitly states a non-goal ('It never sets the industry classification'), which distinguishes it from closely related tools like banking_suggest_industry_code.

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

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

The description gives clear context on what this tool is for and includes an important exclusion: 'It never sets the industry classification: no document states it.' However, it does not explicitly name alternative tools (e.g., banking_confirm_extracted_value or banking_suggest_industry_code) or state exactly when to prefer this tool over those siblings.

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

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

Beyond the readOnlyHint annotation, the description adds meaningful behavioral detail: identifiers are masked to last four digits, full values live in a secret store, and reading full identifiers is deliberately not exposed as a tool due to transcript-leak concerns. This is valuable context an agent needs before relying on the returned data.

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

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

Three sentences, each earning its place: first defines the payload, second gives the canonical use case, third explains the masking behavior. The core content is front-loaded and there is no filler.

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

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

The tool has an output schema, so return-value details are already covered. The description adequately explains the tool's scope, its role as the application-level read, and the important masking limitation. Nothing an agent needs to invoke or understand the result is missing.

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

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

The input schema already documents both parameters as UUID value wrappers, with 100% schema description coverage. The description adds no parameter-level semantics beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description states a specific action and resource: it returns the entire banking application including business facts, owners, documents, data provenance, and outstanding sections. It also gives the tool a clear job: it is 'the one read' for answering where the application stands and what remains.

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 a clear use case: use this when you need the whole application snapshot, especially to answer 'where is my application, and what is left?'. It does not explicitly contrast with sibling tools like banking_get_issuance_state, so it falls just short of full alternative-routing guidance.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds concrete behavioral assurance: 'it moves no money and records nothing.' This goes beyond the structured hints by spelling out the actual side-effect-free behavior, which is valuable for a banking-related 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 short sentences deliver the core purpose and side-effect profile without redundancy. The main action is front-loaded and the read-only clarification is concise and immediately useful.

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

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

For a simple one-parameter read-only tool with an output schema, the description covers what is returned, the side-effect profile, and the resource it applies to. Nothing essential is missing for an agent to select and 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 only parameter, applicationId, is fully documented in the schema as a 'UUID value wrapper' with a nested value property. Schema description coverage is 100%, so the description does not need to add parameter details; the baseline of 3 applies.

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

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

The description states a specific verb ('Returns') and resource ('suggested opening deposit for a banking application and the reason for that figure'). This clearly differentiates it from sibling tools like banking_confirm_initial_transfer and banking_get_banking_application by focusing on a preview of the suggested deposit amount.

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 this is a preview/suggestion tool, so an agent can infer it should be used when the initial transfer amount needs to be shown before any commitment. It does not explicitly name alternatives or exclusions, but the read-only framing provides clear context for when it is appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds behavioral nuance beyond that: that open can still fail after approval and that the tool is deliberately a separate state to avoid misreading an approved application. It does not cover edge cases like pending states in detail, but the key behavior 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?

Three sentences, each carrying meaningful information and the primary purpose is front-loaded. The second and third sentences partially overlap in their warning about application status, but the additional lifecycle context is valuable rather than redundant waste.

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

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

Given a high-coverage input schema, an output schema, and non-destructive read annotations, the description provides enough context—states, the distinction from application status, and the failure-mode rationale—for an agent to call it correctly. It doesn't need to list return fields because the output schema already does.

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

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

Input schema has 100% description coverage for the single parameter, so the description need not compensate; comparison establishes the baseline 3. The description adds only a general implication that applicationId refers to the banking application. No deeper parameter semantics are introduced, which is fine since the schema covers it.

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

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

Description states a precise verb and resource: reports the state of an application's deposit account, with enumerated states (queued, being opened, open, could not be opened) and the last four digits. It also explicitly distinguishes itself from the application's status, so the agent can separate it from banking_get_banking_application.

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 an explicit when: 'a caller that wants to tell somebody they can receive money must read this,' and a when-not: 'not the application's status.' It explains the approval-vs-opening lifecycle so an agent knows why this tool, and not a status tool, is the correct source of truth.

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

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

The description adds concrete behavioral nuance beyond the idempotentHint annotation: running twice updates rather than duplicates, and the applicant's corrections are preserved. This is useful, non-obvious context that the structured annotation alone would not convey.

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

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

The description is two sentences and stays focused: purpose first, then important idempotence detail. The word 'carriable' is awkward and the first sentence echoes the tool name, but the overall structure is tight and front-loaded.

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

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

For a single required parameter with an output schema and safety annotations, the description covers scope, open-application context, and repeated-call semantics. It does not fully clarify what 'carriable' means, but nothing essential prevents an agent from selecting and invoking the tool confidently.

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

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

Schema coverage is 100%, so the single applicationId parameter is already fully documented as a UUID value wrapper. The description does not explicitly tie its behavior to applicationId, so no meaningful parameter semantics are added beyond the schema baseline.

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

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

The description states that the tool moves a company's carriable stakeholders onto an open banking application as beneficial owners, which is a specific verb-resource pair and distinguishes it from formation-based hydration or preview-only tools. It relies on the tool name for the 'from cap table' distinction, and 'carriable' remains somewhat jargon-heavy.

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

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

There is no explicit mention of alternatives like banking_preview_cap_table_hydration or banking_hydrate_from_formation, nor a clear 'when not to use' condition. The phrase 'onto an open application' implies a precondition, but the agent is left to infer workflow ordering.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, and the description adds meaningful context: writes are atomic ('in one transaction'), include provenance, and never overwrite applicant-supplied values. This goes beyond the annotations and clarifies the safety 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?

The description is a single concise sentence that front-loads the most important behavioral fact (idempotence) and avoids redundancy. It could be improved by naming the source and target, but there is no waste.

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

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

For a write operation with an output schema and annotations, the description still leaves key context missing: what data is hydrated, how formationId and applicationId relate, and how this differs from the preview or cap-table hydration flows. An agent would need to inspect sibling tools or schemas to understand the intended use.

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

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

Schema description coverage is 100%, but the parameter descriptions only say 'UUID value wrapper' and provide no semantic meaning. The tool description adds no information about applicationId or formationId, so the agent must infer roles from the tool name. Baseline of 3 is appropriate given full schema coverage.

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

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

The description states the tool writes values and provenance in one transaction, but does not explicitly say what values are hydrated, from what source, or into what target. The name suggests 'from formation,' but the description itself is vague about the resource and scope, and does not distinguish it from banking_hydrate_from_cap_table.

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

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

No guidance is given for when to use this tool versus alternatives such as banking_preview_formation_hydration or banking_hydrate_from_cap_table. The idempotence note is useful but does not help an agent decide between sibling hydration tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value beyond annotations by disclosing an edge-case behavior: the tool is 'unavailable rather than an error when there is nothing to carry.' This is a useful, non-obvious behavioral detail.

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

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

Two concise sentences with no wasted words. The core purpose is front-loaded, and the second sentence adds meaningful behavioral information about read-only status and the no-content edge case.

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 an output schema present and annotations covering the read-only/destructive profile, the description is largely complete. The only minor gap is that it does not explain what 'unavailable' means in practice, but this is a small ambiguity given the rest of the context.

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

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

Schema description coverage is 100%, so the schema already documents companyId as a UUID value wrapper. The description adds no additional parameter meaning beyond implying the company context, so the baseline score of 3 is appropriate.

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