Lovie Company Formation

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

The description adds substantial behavior beyond the annotations: balance and sponsor-bank status are preserved, outgoing money is blocked from now on, in-flight payments are not recalled, and the account is not closed. It also documents idempotency for already-frozen accounts, rejection cases, permission requirements, and the fact that an error means the account remains live.

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

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

The description is dense but front-loaded: it first states the core effect, then the important non-effects, then the parameter sourcing and safety checks. Every sentence carries operational value for a destructive financial action.

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 one required parameter, rich annotations, an output schema, and the high-risk nature of the action, the description is complete. It covers effect, non-effects, idempotency, rejection cases, permissions, and success-reporting guidance.

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

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

Schema coverage is 100%, so the UUID wrapper and required accountId are already documented structurally. The description adds meaningful operational semantics by requiring the id to come from list_accounts rather than the conversation and by requiring confirmation of the account name and status before freezing.

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 suspends a Lovie account. It also clearly distinguishes this action from closing the account and from recalling payments already in flight, so an agent can tell what the tool does without opening the schema.

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

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

It gives strong operational context: retrieve account_id from list_accounts, never rely on the conversation alone, and confirm the account name and current status with the user first. It also lists when the call is rejected, such as closed or linked accounts, but does not explicitly point to the unfreeze sibling as the reversal path.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds nothing beyond that safety profile: 'with its details' is vague and an output schema already exists, so the sentence restates rather than enriches 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?

One front-loaded sentence with no wasted clauses. It is slightly under-specified rather than excessively long, but structurally sound.

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

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

The tool is simple: one fully documented parameter, full annotations, and an output schema that handles return values. The description is sufficient for correct invocation, though it could have more explicitly separated this tool from its list-oriented 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 100% and there is only one required parameter (id), which the schema fully documents as a UUID wrapper. The description's 'by ID' adds no meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (retrieves) and resource (account), and the phrase 'single account by ID' distinguishes it from list-oriented siblings like list_accounts and account_get_list_account_details. It does not explicitly name those siblings, but the single-vs-list scope is clear.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as list_accounts or account_get_list_account_details. The 'by ID' phrasing only weakly implies usage when an account ID is known; no prerequisites or exclusions 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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the batch/non-N+1 behavioral rationale, but says nothing about pagination behavior, result ordering, or what happens when accountIds exceed limits, leaving gaps that annotations do not fill.

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 front-loaded sentence with no filler, and the batch rationale is placed immediately after the core action. It is efficient, though arguably too terse given how much of the parameter surface is left undocumented.

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 not be explained, but with three parameters at 0% schema coverage and no visible description of them, and no clarification versus list_accounts, the definition leaves an agent without enough to invoke it 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 description coverage is 0% and the description does not compensate. The filter.accountIds array (max 100), pageSize (max 100), and pageToken are all undocumented; the phrase 'in batch' only hints at the accountIds filter and gives no format, limit, or pagination semantics.

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

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

States a clear verb+resource (retrieves account details) and adds the batch scope plus an explicit reference to the singular sibling GetAccount. It does not, however, distinguish itself from list_accounts, another sibling that could plausibly cover the same ground.

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 parenthetical '(eliminates N+1 GetAccount calls)' implies the intended usage scenario (fetching many accounts at once), which is useful context. But there is no explicit when-to-use statement and no guidance on choosing this over list_accounts or account_get_account for a single lookup.

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's 'Read-only' adds nothing beyond the annotation; its only incremental value is explaining the possible sources of the fiscal-year start. No permission, rate-limit, or error 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?

One compact sentence, front-loaded with the verb and the returned value. The trailing 'Read-only' is redundant with the annotations and slightly wastes space, but the text is otherwise tight.

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

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

With an output schema present, the description needn't explain return values, and with annotations covering safety it needn't cover read-only behavior either. For a simple single-parameter settings getter, the definition is essentially complete; only a when-to-use cue 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 the single companyId parameter is fully documented in the schema, so the baseline is 3. The description adds no syntax or meaning beyond the schema, but none is needed for a single documented UUID parameter.

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

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

States a specific verb ('returns') and resource (the company's fiscal-year start) plus the provenance of that value (person setting, EIN closing month, or default January). This clearly distinguishes it from the accounting reporting siblings. It stops short of explicitly naming a sibling it differs from, so not a 5.

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

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

There is no statement of when to call this versus alternatives, no prerequisites, and no exclusions. The only hint ('Read-only') is a restatement of the annotation rather than usage guidance. An agent must infer usage from the name alone.

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

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

Annotations already cover the read-only safety profile, and the description adds real behavioral context beyond them: it reads only currently-open items rather than historical snapshots, explains as_of_date semantics, and discloses the no-due-date fallback (aged from issue date, surfaced in aged_from_issue_count). This is substantive data-semantics disclosure.

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 tight sentences with the purpose front-loaded and no filler; each clause adds information. The trailing 'Read-only' lightly duplicates the readOnlyHint annotation, a minor 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?

An output schema exists, so return values need not be re-explained, and the description still names an output field (aged_from_issue_count). It covers behavior and the key date parameter sufficiently for a read-only report; only currency and the nested id wrapper are left to the schema.

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

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

Schema description coverage is only 25%, so the description must carry parameter meaning. It explains asOfDate semantics well and implies the side parameter via AR/AP wording, but says nothing about currencyCode or the nested companyId wrapper. Partial compensation is worth a mid 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?

States a concrete verb+resource ('aging' report of open AR/AP balances) and enumerates the exact buckets returned, which separates it cleanly from sibling reports like trial_balance or balance_sheet. An agent can identify the resource and scope without opening the schema.

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

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

The description implies when the report applies (open AR/AP balances by bucket) and clarifies that as_of_date only affects how overdue items are counted, which guards against misuse. It never names an alternative report or states an explicit when-not-to-use condition, leaving selection against siblings implicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the trailing 'Read-only' is redundant. The genuinely additive part is the accounting behavior: equity includes net income to date so the sheet always balances, which preempts an agent misreading the retained-earnings figure. It still says nothing about permissions, behavior for periods with no closed books, or how missing parameters 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?

A single tightly packed sentence with the primary output (assets, liabilities, equity) front-loaded before the balancing caveat. No filler, though the leading 'GetBalanceSheet' restates the tool name and the description is arguably too terse given the undocumented parameters.

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-shape explanation is not owed here, and the read-only profile is covered by annotations. What remains missing for a 4-parameter financial report tool is any guidance on basis selection and date/currency defaults, which the description does not supply.

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 the companyId UUID wrapper is documented. The description implies asOfDate via 'as of a date' but never explains basis (REPORT_BASIS_ACCRUAL vs CASH vs UNSPECIFIED), what UNSPECIFIED defaults to, or what currencyCode falls back to; the accrual/cash distinction materially changes the numbers and is left entirely to the enum names.

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

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

States a specific verb and resource (returns assets, liabilities, equity balances as of a date), which is more precise than the title alone. However, it does not differentiate itself from near-identical siblings such as accounting_get_trial_balance, accounting_get_profit_and_loss, or accounting_get_statement, leaving the agent to infer which report to pick from the account hierarchy.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no reference to alternative report tools. The only implicit cue is 'as of a date,' which hints at point-in-time reporting but never states the condition that selects this tool over the trial balance or cash flow 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 declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the trailing 'Read-only' is largely redundant. The useful addition is describing what the statement reconciles ('net income, then operating, investing and financing activity, reconciled to the change in bank and cash balances'), but nothing is said about basis handling, currency fallback, or period requirements.

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, and the core purpose is front-loaded. The redundant 'Read-only' tagline is the only wasted token.

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 shape need not be explained, and the description does describe report content. However, for a 5-parameter report tool with a semantically important basis enum and only 20% schema coverage, the absence of any parameter or period guidance leaves real 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 20% and the description adds no parameter meaning at all: basis (an enum whose ACCRUAL/CASH choice materially changes the report), currencyCode, startDate, endDate, and the nested companyId wrapper are all unaddressed. With low coverage the description is expected to compensate and does not.

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

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

States a specific verb and resource ('returns the statement of cash flows for a period') and even lists the line-item structure the report contains. It distinguishes itself from generic report siblings by naming the cash-flow content, but never explicitly contrasts with accounting_get_balance_sheet, accounting_get_profit_and_loss, or accounting_get_statement, so the agent must infer the distinction.

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

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

There is no guidance on when to choose this over the sibling financial statements, no prerequisites, and no exclusions. 'For a period' implies a date range is required but never states whether startDate/endDate are mandatory or how they interact.

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?

Annotations already declare readOnlyHint=true, so the trailing 'Read-only' is redundant, but the description adds substantive behavioral context the annotations cannot: the exact precedence rules that determine which window is returned. It remains silent on edge cases (e.g. what happens with no entries at all), keeping it below 5.

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

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

Three short sentences, front-loaded with the core purpose, then the resolution rules, then the read-only note. No filler and no repetition of schema or annotation content beyond a one-word safety restatement.

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-format detail is unnecessary, and the description still explains the logic behind the returned window. For a single-parameter read tool this covers what an agent needs, though it could note failure behavior when no close target is derivable.

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

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

Only one parameter, and the schema documents it at 100% coverage, so the schema carries the load. The description adds nothing about the companyId semantics or the UUID wrapper, making 3 the correct 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?

States a specific verb+resource: it returns the accounting window the next close must cover, and it spells out the resolution precedence (reopened period > month after closed-through > month of first entry). An agent can distinguish this from generic period getters. It does not name the nearest sibling (e.g. accounting_preview_close) to contrast against, so it stops short of 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?

Usage is implied by the mention that these are 'the same rules ClosePeriod enforces', which situates it before a close workflow, but there is no explicit when-to-use or when-not-to-use statement and no named alternative such as accounting_preview_close or accounting_get_list_periods.

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 'Read-only' is redundant. The description does add interpretive context about what the numbers mean (differences drive reconciliation), which is useful, but it discloses nothing beyond annotations about auth needs, scoping, or limits.

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 output description is front-loaded, and the reconciliation guidance follows logically 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?

An output schema exists, so the description need not enumerate return fields, and it correctly focuses on meaning rather than structure. With full schema coverage and safety annotations, only marginal gaps remain for a single-parameter read tool.

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

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

Schema description coverage is 100% for the single companyId parameter, so the schema carries parameter documentation. The description adds no syntax or constraint detail about the parameter; baseline 3 applies when the schema does the work.

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 resource and scope: per bank account and card, the book balance and posted entry count. The agent can tell what data comes back. It references sibling 'account tools' for the bank balance, but does not sharply differentiate itself from the other accounting_* report 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?

Gives clear context for use: compare against the bank's own balance from account tools, where a difference signals a reconciliation item. That is real when-to-use guidance and points at an alternative source, though it does not state explicit exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, so 'Read-only' in the description is largely redundant. It does add value with 'pages through' (paginated result) and the fact that opening/running/closing balances are computed and returned, but it says nothing about how basis or statement enums change those balances.

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

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

Two tight sentences, front-loaded with the action and resource. 'Read-only' is mild redundancy against the annotations rather than a flaw in structure.

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

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

Purpose and return shape are covered and an output schema exists, but for a 10-parameter reporting tool the omission of how basis/statement/date filters alter the ledger is a real gap an agent must guess at.

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?

Ten parameters at 20% schema description coverage, including two undescribed enums (basis accrual vs cash, statement P&L), date range, vendor, currency, and nested UUID wrappers. The description only hints at single-account scoping and paging, leaving most parameters undocumented anywhere.

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 ('pages through one account's posted lines') and adds the distinguishing detail that it is the single-account register with opening/running/closing balances. That separates it conceptually from trial balance or P&L siblings, though it never names 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 phrase 'the account register' implies the use case (drilling into a single GL account's activity), but there is no explicit when-to-use or when-not versus accounting_get_trial_balance, accounting_get_profit_and_loss, or accounting_get_list_journal_entries.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds one genuinely useful behavioral fact beyond that: it returns empty when no entry exists yet, and that the entry is 'derived' rather than stored. No mention of auth requirements or error behavior.

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

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

A single front-loaded sentence carries the purpose plus the empty-result behavior, followed by a terse 'Read-only.' It is efficiently sized, though the trailing 'Read-only.' largely restates the readOnlyHint annotation rather than earning 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. For a simple two-param read-by-id tool the description is nearly complete, with only usage routing to alternatives left unaddressed.

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, transactionId) are documented as UUID value wrappers in the schema. The description adds no format, constraint, or relationship detail beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb+resource (returns the journal entry) scoped to a single transaction, which cleanly separates it from the sibling accounting_get_list_journal_entries. It is clear on its own, but does not explicitly name that sibling or contrast the two.

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 a lookup keyed on a transaction but gives no when-to-use guidance, no prerequisites, and no pointer to alternatives like the list endpoint or general ledger. The agent must infer the use case from the name alone.

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

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

'Read-only' merely restates readOnlyHint=true, contributing nothing beyond the annotations. 'Pages through' gestures at pagination behavior, but pageSize/pageToken in the schema already make that obvious. No auth requirements, rate limits, or result-scoping caveats are disclosed. With annotations carrying the safety profile, this is a bare-minimum 3.

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

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

One tight sentence with the action front-loaded and the useful filter hint set off by an em-dash. Nothing is redundant. It is arguably a touch too compact for a tool with a ten-field nested filter, but there is no wasted text.

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

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

An output schema exists, so return values need no explanation, and annotations cover safety — both reduce the burden. Still, the description leaves a complex nested filter almost entirely undocumented and is silent on the three top-level parameters, which is thin for a paged list tool. Adequate but with 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%, so the description should carry more weight, and it adds meaning to exactly one field by naming a filter key. That key is written as 'needs_review' while the schema property is 'needsReview', a casing mismatch that could mislead. The other filter subfields and pagination parameters get no explanation at all.

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 ('pages through the journal register with filters'), which is enough to distinguish it from report tools like get_trial_balance or get_general_ledger. It also implicitly separates itself from the review-item tools by pointing out that the review queue is a filter view here. Sibling routing is hinted at rather than explicit, so it falls short of a 5.

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

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

It supplies one concrete usage pattern — 'the review queue is filter{needs_review: true}' — which tells an agent how to reproduce a review workflow. However, it never says when to prefer this tool over accounting_get_list_review_items, accounting_get_journal_entry_by_transaction, or accounting_get_general_ledger. Usage is demonstrated, not framed as a choice between 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, destructiveHint=false and openWorldHint=false, so 'Read-only' merely repeats structured data. The description does add genuinely new behavior beyond the annotations: default ordering ('newest first') and the fact that results are paginated. It does not disclose page-size limits or filter 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 short sentences with the core operation and ordering front-loaded and no filler. It is efficient, though the terseness borders on under-specification rather than true economy.

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 not be described, and the read-only nature is covered by annotations. However, for a 4-parameter listing tool with nested filter objects and low schema coverage, the absence of any filter/status/pagination guidance leaves real 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%, so the description carries more burden than it does. It implies the required company scoping and pagination but says nothing about the 'filter.statuses' enum (OPEN/CLOSED), the 100-item pageSize cap, or pageToken handling.

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 (pages through / lists) and resource (a company's periods) with a scope detail (newest first). It is distinguishable from accounting_get_period (singular) by the plural resource, though it never names that sibling 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?

No when-to-use guidance and no alternatives named, even though accounting_get_period and accounting_get_list_journal_entries sit right next to it. The only implied usage cue is 'pages through', which hints at large result sets but states no condition.

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 readOnly/non-destructive/closed-world, and the description goes further by clarifying that every row is already booked and the tab merely records sign-off — a non-obvious semantic that prevents misreading the data. It also discloses the row payload and that counters for all three tabs come back, which is behavior beyond the annotations.

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

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

Front-loads the one-line purpose, then expands the tab definitions and row shape. Dense but every clause carries information; the heavy parenthetical definitions are the only place it feels crowded.

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 purpose, bucket semantics, and return shape adequately. The gap is input-side: with 25% schema coverage on a rich nested filter object, an agent gets no description-level guidance on the filtering, paging, or scope parameters.

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% and the description names no parameters directly. It does implicitly explain the bucket filter by spelling out PENDING/REVIEWED/EXCLUDED, but the other filter dimensions (search, dates, amounts, glAccountIds, bookingSource, splitOnly, unbookedOnly) are left entirely to the schema.

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

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

States a specific verb and resource ('List bank transactions awaiting bookkeeping review') and implicitly scopes itself against siblings like accounting_get_review_counts and accounting_get_similar_review_items by naming the exact object set (review items in the books). An agent can select it without opening the schema.

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

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

Defines the three tab semantics in detail (PENDING = nobody reviewed the booking, REVIEWED = person-signed and unchanged, EXCLUDED = kept out of the books), which tells the agent exactly which bucket to choose and what each implies. It gives clear context but does not explicitly name or route to alternative sibling tools.

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

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

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 declare readOnlyHint, destructiveHint, and openWorldHint, so 'Read-only' is largely a restatement. The one piece of added behavior is that only a *closed* period is returned, which is a genuine data-availability constraint beyond the annotations, but it is not elaborated (e.g., what happens if the period is open).

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 operation. The trailing 'Read-only' is redundant against the annotations, a small amount of waste, but overall the text is tight and appropriately sized.

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 parameters are covered by the schema. However, for a lookup tool in a dense accounting family, the absence of routing guidance versus list_periods and of any error/not-found behavior leaves it only minimally 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 100% and both UUID wrappers are documented in the schema, so the baseline is 3. The description's 'by id' adds nothing beyond what the schema already specifies and does not clarify the required companyId scoping.

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 one closed period by id') and scopes it to a single closed period, which distinguishes it implicitly from the sibling accounting_get_list_periods. It stops short of naming that sibling explicitly, so it is clear but not fully differentiated.

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

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

There is no when-to-use guidance, no statement of prerequisites or when an agent should prefer this over accounting_get_list_periods or accounting_get_statement. 'Read-only' is a trait, not usage guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, and the description's only behavioral claim ('Read-only') merely repeats that. The remaining text describes return contents, which the output schema already covers, so little is added beyond structured fields.

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 front-loaded sentence with no filler; the core purpose and scope land immediately. It is efficient, though arguably too terse given the tool's parameter surface.

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 six-parameter financial report with low schema coverage, no annotations beyond the safety trio, and meaningful options like reporting basis and vendor breakdown, the description omits the context an agent needs to invoke it correctly. The output schema excuses return-value detail but not parameter and mode guidance.

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

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

Schema description coverage is only 17% across 6 parameters, yet the description mentions no parameter at all - not basis (accrual vs cash), byVendor, currencyCode, or how the wrapped companyId should be supplied. 'For a period' is the sole weak nod toward startDate/endDate, leaving the documentation burden unmet.

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 income statement for a period') and enumerates contents (revenue/expense accounts, totals, net income), which inherently separates it from balance sheet or cash flow siblings. However, it never names an alternative sibling explicitly, so it falls short of the 5-level sibling differentiation bar.

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?

Only an implicit hint that it operates 'for a period'; there is no when-to-use guidance, no comparison to accounting_get_balance_sheet or accounting_get_trial_balance, and no stated prerequisites or exclusions. An agent gets no routing help.

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 closed-world, so the safety profile is covered and "Read-only" is largely redundant. The description does add real behavior — one statement per period at the requested granularity, figures identical to the single-period calls — but says nothing about defaults for the optional kind/basis/granularity/date/currency fields or any cap on range size.

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

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

Two tight sentences with the core scope front-loaded; nothing is padded. The trailing "Read-only." duplicates readOnlyHint and the equivalence clause slightly restates the opening, but the waste is minimal.

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 values need not be explained, and the multi-period semantics are clear. However, for a 7-parameter tool with a nested UUID wrapper and five optional fields whose defaults are undisclosed, the description leaves a real gap about what happens when startDate/endDate/granularity/basis are omitted.

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 14%, so the description must carry the load; it partially does by naming the three report kinds and the three granularities, plus the date-range concept. It leaves basis (accrual vs cash), currencyCode, the companyId UUID wrapper, and all defaulting behavior undocumented.

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

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

States a specific verb and resource (returns one P&L / balance sheet / cash flow statement per period) plus the exact scope (month/quarter/year across a range) and explicitly contrasts with the single-period RPCs. An agent can distinguish it from accounting_get_profit_and_loss, accounting_get_balance_sheet and accounting_get_cash_flow_statement without opening any schema.

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

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

"in one call: the same figures the single-period RPCs give for each period" implicitly tells the agent to prefer this over repeated single-period calls when a range is needed. It does not name the sibling tools explicitly or state an exclusion case, so it stops short of a full when/when-not rule.

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 covered. The description adds one useful behavioral trait — this returns counts rather than rows, making it a cheap summary call. It does not add auth requirements, rate limits, or scope constraints beyond that.

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

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

Two tight sentences: the first front-loads what the tool returns and its scope, the second states the use case. No filler, no restating of the name or annotations.

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-parameter read-only count tool with a full output schema, the description covers what is counted and when to use it. Return shape is left to the output schema, which is appropriate. Only the vague companyId scoping is unaddressed in prose, a minor gap.

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

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

Schema description coverage is 100% and there is only one parameter (companyId), so the schema already documents it fully. The description adds no further meaning to the parameter, which is the expected baseline when the schema does the heavy lifting.

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 (Count) and resource (bank transactions per bookkeeping review tab), and enumerates the exact tab categories (pending, reviewed, excluded). The phrase 'without fetching rows' implicitly distinguishes it from the row-fetching sibling accounting_get_list_review_items, so an agent can tell the two apart.

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?

'Use to report how much review work is outstanding' gives a clear triggering scenario, and 'without fetching rows' hints at the lightweight-count alternative to listing items. There is no explicit when-not guidance or named alternative tool, but the usage context is unambiguous.

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

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

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 cover the read-only, non-destructive, closed-world profile, and the description adds substantial context beyond them: a 500-id cap, newest-first ordering, total_count that can exceed returned ids, the fact that rows only leave Pending after human acceptance and ledger posting, that repeat calls return already-booked ids, and that re-proposing the same Category replaces the prior proposal. That is exactly the lifecycle and idempotency information an agent cannot get from structured fields.

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

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

Front-loaded with purpose, then return shape, then the follow-up action, then lifecycle caveats — a logical progression with no filler. The trailing 'Read-only.' is redundant with readOnlyHint and the middle sentences are dense, but nothing else could be cut without losing behavioral detail.

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

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

Even though an output schema exists, the description goes further and explains ordering, the 500 cap, and the total_count-vs-returned-ids discrepancy, plus the human-in-the-loop dependency that governs re-calling. For a two-parameter read tool this covers everything an agent needs to call it and interpret the result correctly.

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

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

Schema coverage is 100% and both params are typed UUID wrappers, so the schema does the heavy lifting. The description still adds meaning by framing transactionId as the already-booked anchor transaction whose counterparty and cash direction drive the match, which the bare 'UUID value wrapper' does not 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 verb and resource plus a tight scope: find the *other* pending transactions from the same counterparty in the same cash direction. The parenthetical '(money out vs money in)' makes the matching rule unambiguous, which clearly separates it from the broad sibling accounting_get_list_review_items.

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 an explicit trigger ('After booking one transaction') and an explicit next step ('Book them in one call with transaction_batch_assign_transaction_category'), plus guidance for the overflow case. It never names the obvious alternative, accounting_get_list_review_items, so the agent has to infer when to browse all review items instead of similar ones.

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, so the description's 'Read-only' simply restates structured data. It does add one genuinely useful behavioral fact: total debits equal total credits when the books balance, which tells the agent what a balanced result looks like. No mention of permissions, pagination, or basis behavior, but with annotations covering safety this is adequate.

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 sentence plus 'Read-only.' Front-loaded with the core purpose and no wasted words. The trailing 'Read-only' is redundant against annotations but costs little.

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 not be re-explained. For a read-only report tool with one required parameter, the description is minimally complete, but the five under-documented parameters and unfiltered sibling landscape leave real 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 20%, so the description carries a heavier burden, yet it adds no parameter meaning. 'For a period' vaguely implies startDate/endDate but does not clarify the enum basis values, the required companyId UUID wrapper, or currency code semantics. It 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?

States a specific verb and resource: returns every account's debit and credit totals for a period. This is clear and distinct from a general ledger or balance sheet at a conceptual level, though it never explicitly contrasts itself with those siblings. Clear purpose without sibling differentiation.

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

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

There is no guidance on when to choose a trial balance over the many sibling report tools (balance_sheet, profit_and_loss, general_ledger). No prerequisites, no exclusions, no alternatives named. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered; the description's 'Read-only' largely restates that. However, it adds genuinely new behavior: the log is append-only, it is paginated ('pages through'), and results are returned newest first — none of which the annotations convey. It does not mention rate limits or retention windows.

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, zero padding — the resource scope lands first, the filtering hint second, and the read-only signal last. Every clause carries information and nothing is repeated from the title or 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?

An output schema exists, so return values need not be explained, and the annotations cover the safety profile. The description supplies scope, ordering, and the key filter, leaving only minor gaps around pagination mechanics and the required companyId for a 4-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?

With schema description coverage at 50% (entityId and companyId carry only a generic 'UUID value wrapper' text, pageSize and pageToken have none), the description does useful work by explaining that entity_id selects one record's history and that paging is in play. It still says nothing about pageSize bounds, pageToken semantics, or the companyId requirement, so it only partially compensates for the coverage gap. Baseline 3 applies.

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

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

States a specific verb (lists/pages through) and a precisely scoped resource (the append-only accounting audit log covering journal entries and the chart of accounts), plus the ordering (newest first). An agent can tell exactly what data comes back. It does not explicitly differentiate itself from the sibling cap_table_list_cap_table_audit_events, but the accounting domain scoping is unambiguous.

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

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

Provides one concrete usage condition — filter by entity_id to get a single record's history — which tells the agent how to narrow results. It offers no when-not guidance, no prerequisites, and names no alternative list tool, so guidance is implied rather than complete.

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 still adds real information about what the blockers mean and where they originate (the ClosePeriod precondition set), plus that it reports carry-over effects of closing. It does repeat the annotation ('without writing anything', 'Read-only'), which is redundant rather than harmful.

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 what is computed before explaining blocker provenance. Slight redundancy in restating read-only twice ('without writing anything' and 'Read-only'), and 'what closing carries with it' is vague filler, but overall it is compact and earns most of its space.

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

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

An output schema exists, so return-value detail is not required, and the read-only behavior is well covered. However, for a five-parameter tool with nested companyId and two enums, the description leaves all parameter semantics unaddressed, which is a meaningful completeness gap for a preview/computation 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 only 20% and the description never mentions any of the five inputs — basis, startDate, endDate, granularity, or the companyId wrapper. It says nothing about how date range or report basis change the computed totals, so it fails to compensate for the undocumented schema. An agent must infer parameter meaning entirely from enum names.

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

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

The description states a specific verb and resource: it computes per-currency revenue/expense totals and net income for a prospective close, and reports blocking preconditions. That is far more informative than the name alone and clearly separates it from get-style tools like accounting_get_trial_balance or accounting_get_close_target, though it never names a sibling to route against.

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 operating context: the blockers come from the same preconditions ClosePeriod refuses on, so a clean preview means the close won't be refused. That tells the agent when this is the right call (dry run before closing) and what a clean result implies. It stops short of explicit exclusions, e.g., when to use a different reporting tool instead.

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

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

Annotations already provide readOnlyHint=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 establish readOnlyHint=true and destructiveHint=false, but the description adds meaningful workflow context: 'Returns proposals only — nothing is created until a person creates the schedule in the app.' That non-mutating, human-in-the-loop behavior is valuable beyond the annotations, and it also enumerates the fields of each proposal.

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

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

Three tight sentences, front-loaded with the core action and example, then the critical 'proposals only' constraint, then the proposal contents. No filler; 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?

An output schema exists, so the description need not explain return values, yet it helpfully summarizes what each proposal contains. Combined with the annotations and schema, an agent has enough to call it correctly; only explicit sibling routing is absent.

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 there is only one parameter (companyId), which the schema fully documents as a UUID wrapper. The description adds no parameter-specific meaning, so the baseline 3 applies.

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

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

The description gives a specific verb+resource: 'Scan a company's recent posted transactions and suggest accrual schedules', with a concrete example (amortizing a prepaid). It is clearly distinguishable in intent from get_list_schedules and preview_schedule, though it never names or contrasts those siblings 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 by the scan-and-suggest framing, but there is no explicit when-to-use or when-not-to-use guidance, and no mention of the alternatives (accounting_preview_schedule, accounting_get_list_schedules) that an agent would need to choose between. It clarifies scope ('recent posted transactions') but not routing.

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

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

Annotations already establish that this is a safe read (readOnlyHint=true, destructiveHint=false), so the 'Writes nothing' line is largely redundant. However, the description adds genuinely useful behavioral detail beyond annotations: the matching algorithm (exact amount match, then date proximity and description ranking).

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 tightly written sentences, front-loaded with the core action, followed by the matching logic and the safety note. No filler; 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 an output schema present, return values needn't be explained. The description covers purpose, matching logic, and non-mutating behavior adequately for a 2-parameter read tool. Only the absence of explicit alternative-tool routing keeps it from a 5.

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 (statementId, companyId) are documented in the schema. The description adds no parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description gives a precise verb and resource: 'Rank ledger transactions against a statement's unmatched lines.' An agent immediately understands this is a candidate-scoring tool for reconciliation. It does not explicitly name a sibling (e.g., accounting_suggest_transfer_pairs), so it falls just short of the explicit-differentiation bar.

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 the usage context clearly — matching against a statement's unmatched lines with a human applying the final match on the reconcile screen. It communicates the advisory nature of the tool but doesn't name alternatives or state explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Writes nothing — a person confirms a pair in the app,' which adds the human-in-the-loop workflow that annotations cannot express. It also discloses the heuristics used for ranking, which is genuine behavioral context beyond the structured fields.

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 core purpose plus matching criteria are front-loaded before the read-only reassurance. 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?

An output schema exists, so return values need not be explained, and the description covers purpose, matching heuristics, and the no-write/human-confirmation behavior. The only remaining gap is parameter-level meaning, which is minor given the small two-parameter surface.

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

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

Schema coverage is 100%, so the baseline is 3. The description implies that the input is a single journal entry whose counterpart is being sought, but it never explains what companyId or journalEntryId mean or how the two interact, and the schema's own descriptions are only generic 'UUID value wrapper' strings.

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 (rank) and resource (journal entries that could be the other half of a transfer) and enumerates the matching criteria: opposite direction, same amount, different instrument, within a few days. It is highly distinctive from siblings like suggest_statement_matches, though it does not explicitly name a sibling to differentiate against.

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 matching criteria imply when the tool is applicable (finding the counterpart entry of an internal transfer), but there is no explicit when-to-use statement, no exclusions, and no named alternative such as suggest_statement_matches or get_similar_review_items. Usage must be inferred.

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?

Goes well beyond the annotations by explaining that an already-active account is returned unchanged and successfully (concrete semantic of idempotentHint), that a closed account can never be reopened, and that banking.account.freeze permission is required. This is exactly the behavioral context the annotations alone cannot 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?

Front-loaded with the action and the hard constraint, and nearly every clause carries decision-relevant information. The middle clause ("and this is not the route back from those states - report the state...") restates the preceding sentence a bit, costing some tightness.

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 one required parameter, full schema coverage, annotations, and an output schema, the description covers everything the agent needs: eligibility, permission, id sourcing, and idempotency semantics. No gaps remain.

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

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

Schema coverage is 100% with a single required parameter, so the baseline is 3. The description adds genuine value by mandating the id come from list_accounts rather than conversation memory, though it names the parameter "account_id" while the schema uses "accountId", a minor inconsistency.

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 ("Lifts a freeze and returns the account to active") and immediately scopes it to frozen accounts only, which distinguishes it from account_freeze_account and from state-changing siblings like card_unfreeze_card. An agent can select this without opening the schema.

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

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

Explicitly enumerates the when-not cases (dormant, restricted, closed) and gives the alternative action for those cases ("report the state the account is actually in instead of calling this"). It also prescribes the prerequisite for obtaining account_id from list_accounts.

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

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

Adds substantial context beyond the annotations: the rename is mirrored at the sponsor bank, an error may mean the sponsor rejected it leaving the name unchanged, linked accounts are refused, and a specific permission (banking.account.update) is required. This is exactly the kind of side-effect and failure-mode detail the destructiveHint/openWorldHint annotations cannot 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?

Purpose is front-loaded in the first clause, and every subsequent sentence carries operational value. The semicolon-chained middle sentence is dense but not padded.

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

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

Output schema exists, so return-value explanation isn't required, yet the description still adds a useful reporting rule ('report the name the call returned, not the one you sent'). Combined with auth, refusal modes, and ID provenance, an agent has everything needed to call and 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 coverage is 100%, so the baseline is 3; the description goes further by specifying the provenance requirement for account_id (fetch via list_accounts, never infer from conversation). It says little extra about displayName beyond what the schema's length constraints already state.

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 ('Renames a Lovie account for display') and immediately constrains scope (display name only, propagated to the sponsor bank). It is easily distinguished from read siblings like account_get_account or account_freeze_account.

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

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

Gives concrete pre-call rules: get account_id from list_accounts rather than the conversation, and tell the user which account is being renamed first. It also flags the linked-account exclusion. It stops short of naming an alternative tool for cases this one can't handle, but the when-to-use context is clear.

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

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

With 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 declare openWorldHint=false and destructiveHint=false; they do not declare readOnly, and there is no readOnlyHint. The description adds genuinely useful behaviour: results are cached per company + account + window + charge, and it reveals that an agent is run behind the scenes ('do not re-run the agent'), hinting at cost. It does not say what permissions are needed, what happens on a cache miss, or how the cache is invalidated.

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

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

Two tight sentences, front-loaded with the core behaviour and followed by a caching rationale. The only waste is the redundant lead 'SummarizeCampaignWindow summarises', which restates the tool name before getting to the point, and the whole thing arguably under-specifies rather than over-explains.

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 not be documented, which lifts some burden. However, with 6 fully undocumented parameters, all-optional inputs, and only partial annotations, the description does not fully equip an agent to call it correctly (e.g. what provider to pass, whether all params are required for the cache key).

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% across 6 parameters, and none have inline descriptions. The description partially compensates by naming company, account, window, and charge, which maps loosely to companyId, accountId, periodStart/periodEnd, and chargeAmount, but it says nothing about provider (the only enum), the date format/locale, or which of the charge parameters selects the charge.

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 object: it summarises one charge against the campaigns falling in its billing window. That is distinguishable from ads_insight_summarize_ad_spend in principle, but it never names or explicitly differentiates itself from the per-provider campaign-window siblings, so an agent must infer the boundary.

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

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

There is no explicit when-to-use, no when-not-to-use, and no named alternative among the many ads_/google_ads_/meta_ads_ campaign-window tools. The only usable cue is 'repeated panel opens', which implies a display-time summarisation context, but this is inferred rather than 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 declare readOnlyHint=true, and the description reconciles the apparent 'propose' verb with that by stating 'This does not execute anything' and that the founder enters data and approves in the native app. It also adds the re-read-before-claiming-success protocol and the no-secrets constraint, which annotations alone would not convey. It stops short of saying what happens when the gating condition is not met or how the proposal surfaces, so a 4 rather than 5.

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?

Purpose and the gating condition come first, and every sentence carries information: constraints, non-execution semantics, per-kind parameter routing, and sibling routing. The conditional parameter rules are a dense run-on that could be bulleted, but nothing is filler.

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

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

For a complex, enum-driven tool with five optional nested fields and only one required top-level parameter, the description supplies the gating logic, the safe-input contract, the human-approval model, and which IDs each action kind needs. Return values are covered by the output schema and safety by the annotations, so the remaining gaps (firmCode, failure mode) are minor.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does: it maps action kinds to required fields (company_id except pre-company founder/shareholder actions, domain actions take domain, application/MONEY_RECEIVE take resource_id, SIGNATURE_SEND takes resource_ref, child tax actions take subject_id). The 'firmCode' parameter is never mentioned and the casing differs from the schema ('company_id' vs 'companyId'), leaving one real 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?

States a specific verb and resource ('proposes a native Mac secure action sheet or confirmation card') plus the gating condition ('when the chat context advertises native secure action support'). It also names what it is not ('Transfers are not a native action'), so an agent can separate it from the transfer siblings without opening a schema.

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

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

Gives explicit preconditions (context must advertise native support), explicit exclusions (transfers must go through the transfer tools: draft, phone approval, commit), and a negative instruction ('Never call raw sensitive setters or request a value in chat'). The alternatives are named rather than 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 only declare openWorldHint=false and destructiveHint=false, so the description carries the real burden and does: human-in-the-loop latency, push delivery, is_simulation_available behavior change, minutes-long expiry, and single-use consumption. These are exactly the traits an agent could not infer from 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?

Front-loaded with the mechanism first, then the workflow, then the simulation exception and lifetime constraints. No filler sentences, but the workflow is delivered as one long chained sentence that a numbered sequence would make easier to scan.

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

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

For a 6-param, nested-object, output-schema-bearing tool this covers the workflow, prerequisites, expiry, single-use semantics, and the simulation branch, so no return-value explanation is needed. The remaining gap is guidance on the origin and description parameters that an agent must still supply.

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

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

Schema coverage is only 17% across 6 params, so the description must compensate. It meaningfully constrains actionType and actionPayload ('the exact action_type and payload the tool documents') and implies the session id return, but says nothing about originLocation, originPlatform, actionDescription, or the originTrustedDeviceId wrapper, leaving four parameters opaque.

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 (opens) and resource (a sensitive-action approval session) and immediately describes the mechanism: a push notification to the user's trusted device. It is clearly distinguishable from the sibling approval_session_get_approval_session_status, which it names as the polling counterpart.

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 explicit when-to-use triggers (before the domain auth-code reveal, trademark firm handoff, ITIN submit), the full call sequence (create, tell user to check phone, poll status until APPROVED, pass session id to the gated tool), and a fork for the simulation case where no push is sent.

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 behavior the annotations cannot: the ~5 minute expiry window after the session was opened and the explicit anti-polling instruction ('not in a loop'), which is real operational context. It stops short of describing the response shape, though an output schema exists.

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

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

Front-loaded with the core action and the status values, then layers usage constraints and lifecycle facts in two tight sentences. Every clause earns its place; no filler or redundant 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?

For a polled status tool with annotations covering safety and an output schema covering return values, the description supplies everything else an agent needs: the possible statuses, the caller sequence, the polling cadence, and the expiry window. Nothing material 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% and there is only one parameter, so the schema carries the type/format burden. The description goes beyond it by specifying the provenance of the value ('the approval_session_id from request_transfer_approval'), which tells the agent where to obtain the id rather than just its shape.

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 ('Read the status of a trusted-device approval session') and enumerates the exact status values (PENDING, APPROVED, REJECTED, EXPIRED), which pins the resource down precisely. It is clearly distinguishable from the sibling request_transfer_approval and commit_transfer that it references.

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

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

Explicitly names the trigger (once the user says they have answered on their phone), the id source (from request_transfer_approval), the downstream action gated on the result (call commit_transfer only when it returns APPROVED), and the polling policy ('once per user prompt, not in a loop'). This is textbook when/when-not/alternative guidance with nothing left to inference.

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

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

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 declare idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine state-machine context beyond that: skipping confirmation leaves the section open indefinitely and blocks application submission. It does not say what happens to the underlying value or what permissions are needed.

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 the consequence front-loaded after the purpose statement, and no filler. Minor redundancy in opening with the camel-cased tool name, which restates 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 needn't be explained, and annotations cover idempotency. Still missing for a two-param mutation tool: the meaning/optionality of fieldPath, the notion of 'section' it holds open, and how confirmation interacts with re-extraction. Adequate but with 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 50% and the covered parameter (applicationId) only carries a bare 'UUID value wrapper' note. The description says nothing about fieldPath: its path syntax is only implied by the pattern, and its optionality (not in required) leaves unclear whether omitting it confirms the whole section or is an error.

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?

Specific verb-plus-resource: records that a human verified an extracted (read) value. An agent can distinguish it from extraction tools like banking_extract_document_fields and from update tools. It doesn't explicitly name the sibling it replaces when a value is wrong rather than merely unconfirmed.

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 second sentence implies the trigger condition (a low-confidence extraction is blocking its section and preventing submission), which is useful implicit guidance. However, there is no explicit 'use when'/'do not use when', and no routing to the alternative (editing the value via banking_update_banking_application instead of confirming 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?

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?

Beyond the sparse annotations, the description discloses that the tool reads a document, fills in stated values, annotates each value with its source and confidence, and explicitly does not set industry classification. This is meaningful behavioral context. It still does not say whether existing values are overwritten, what permissions are required, or whether extraction is idempotent.

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, front-loaded, and every sentence adds useful information. The document types, provenance/confidence behavior, and industry-classification exclusion all earn their 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 two-parameter extraction tool with an output schema, the description is largely complete: it explains what is read, what is filled in, and one important limitation. It is not fully complete because it omits overwrite/merge behavior and workflow guidance around confirmation or later review.

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

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

Schema description coverage is 100%, so both required parameters are already documented as UUID value wrappers. The description only indirectly maps them by saying the document belongs to a banking application. Baseline 3 is appropriate because the schema does the heavy lifting.

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 gives a specific verb and resource: it reads an uploaded banking-application document and fills in values from it. It also scopes the accepted document types and explicitly excludes industry classification, which distinguishes it from the industry-suggestion sibling. It does not, however, distinguish itself from close siblings such as banking_confirm_extracted_value.

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

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

The description implies the tool is used on an uploaded document within a banking application and names the relevant document types. It also gives a useful when-not signal: it never sets industry classification. But it provides no explicit workflow guidance, prerequisites, or named alternatives such as the confirmation tool.

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

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

Beyond readOnlyHint/destructiveHint=false/closed-world, it discloses a non-obvious behavioral trait: identifiers are truncated to the last four digits, so an agent won't chase a full EIN in the response, and the reasoning (transcript safety) is explained. This is exactly the kind of context annotations cannot 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?

Opens with what it returns and follows with the selection rule, so it is well front-loaded. The closing clause 'a whole identifier in a tool call is a whole identifier in a transcript' is rhetorical flourish that restates the prior sentence, slightly over budget.

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-shape explanation isn't required, yet the description usefully summarizes the payload and pre-empts the biggest agent surprise (redacted tax identifiers). It omits nothing critical, though it could say whether calls must be scoped by companyId, applicationId, or both given zero required params.

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

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

Schema coverage is 100% and both parameters are UUID wrappers documented in the schema, so the schema carries the semantics. The description never mentions companyId or applicationId, adds nothing about scoping between them, and notably does not flag that neither is required. Baseline 3.

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

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

States a specific verb and resource and then enumerates the payload: business facts, beneficial owners, uploaded documents, value provenance, and outstanding sections. The line 'It is the one read for answering where is my application, and what is left?' sharply separates it from the write siblings (banking_set_*, banking_update_*, banking_submit_*) that share the resource.

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

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

'It is the one read for answering...' gives a clear selection rule for when to call it rather than the many mutation tools in the banking_* family. It stops short of naming an alternative or exclusion, so the agent must infer the boundary with neighbors like banking_get_issuance_state or banking_get_initial_transfer_preview.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful non-annotation semantics: approval is the partner accepting the corporation, opening happens afterward and can still fail, and an approved application must not be mistaken for an open account. It stops short of mentioning auth or freshness/polling behavior, so 4 rather than 5.

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, all front-loaded with the core purpose first, then the state-enumeration rationale. Every sentence earns its place, though the approval-vs-open explanation is slightly repetitive with the earlier statement.

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 not be explained, and the description still names the state values and the last-four-digits detail. It complements the read-only annotations adequately; only auth/freshness expectations are absent, which is a minor gap.

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

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

Schema description coverage is 100% for the single applicationId parameter, so the schema already documents it. The description adds nothing about the parameter (e.g., which application ID, relationship to the banking application flow). Baseline 3 applies when the schema does the heavy lifting.

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 ('reports where this application's deposit account stands') and enumerates the states it returns (queued, opening, open, failed) plus last four digits. It explicitly differentiates itself from the banking application's status, so an agent can pick it apart from banking_get_banking_application without opening either schema.

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

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

Gives an explicit when-to-use: a caller who wants to tell somebody they can receive money must read this, not the application's status. It names the alternative concept (application status) and the condition that selects this tool over it.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, but the description earns credit by explaining the mechanism: the stakeholder link is the identity key, re-running updates rather than duplicates, and applicant corrections are preserved. That is genuinely additive context an agent could not infer. It does not cover behavior on a non-open application or partial-failure cases.

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

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

Two tight sentences, front-loaded with the action and followed by the idempotency guarantee. Every clause carries information; nothing is restated from the schema or annotations verbatim.

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, a single well-documented parameter, and safety annotations, the description supplies the key missing context: what data moves and what happens on re-run. Minor gaps remain around error/edge behavior and the meaning of 'carriable', but an agent has enough to invoke it correctly.

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

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

There is a single required applicationId wrapped in a UUID value object, and schema description coverage is 100%, so the baseline is 3. The description implies an 'open application' target but adds no further meaning about the parameter's format or constraints beyond the schema.

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

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

States a specific action (carry carriable stakeholders onto an open application as beneficial owners), naming both the source (cap table) and destination resource. The source distinction implicitly differentiates it from the sibling banking_hydrate_from_equity_intake and banking_hydrate_from_formation, though it never says so 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?

The phrase 'onto an open application' implies the pre-condition that an application must already exist and be open, which is useful. However, it gives no explicit guidance on when to choose this over banking_hydrate_from_equity_intake, banking_hydrate_from_formation, or the corresponding banking_preview_cap_table_hydration dry-run tool.

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

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

The annotations already declare idempotency and a non-destructive profile, but the description adds a meaningful behavioral guarantee: it never overwrites values supplied by the applicant. That merge behavior is important context beyond the structured annotations, though no auth or rate-limit details are given.

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

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

The description is two tight sentences with the core action front-loaded and the key overwrite guarantee second. There is no redundant or filler language.

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

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

The tool has a complete schema, annotations, and an output schema, so the description does not need to explain return values. It gives the core behavior and an important merge rule, though it could more explicitly position the tool against sibling hydration and preview tools.

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?

There is only one parameter, and the schema has 100% description coverage with a nested UUID wrapper already documented. The description does not mention applicationId or add syntax or constraints beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb and clearly identifies both the source (equity intake) and target (an open application), so an agent can infer this is the equity-intake hydration path. It does not explicitly distinguish itself from sibling hydration tools such as banking_hydrate_from_cap_table or banking_hydrate_from_formation, keeping it 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 'onto an open application' implies the tool should be used when an application already exists and equity intake facts are available. However, it does not explicitly state when to choose this over the sibling preview or hydration tools, nor does it describe prerequisites or exclusions.

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