Vitafin

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

Beyond the annotations, the description discloses that 'Id is derived from the name unless given,' which is a meaningful behavioral detail not visible in the schema. It does not address duplicate handling or side effects, so it is adequate but not rich.

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

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

One sentence conveys creation, parent relationship, and ID derivation with no filler. The most important behavior 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 5-parameter creation tool with an output schema, the description covers the core behavior and unusual ID rule, and the schema covers icon and kind. It omits duplicate-name behavior and explicit alternatives, but those are not required for a basic invocation.

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

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

Schema description coverage is only 40%, and the description compensates for two undocumented parameters: id (derived from name) and parent_id (sub-category placement). It does not elaborate on name, but the explicit id behavior gives the most important missing semantics.

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

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

The phrase 'A new category' clearly describes a creation action on the category resource, and '(or sub-category under a parent)' adds scope. It does not explicitly contrast with update_category, so it falls short of full differentiation.

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

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

The description implies when to use the tool by emphasizing 'new' and by mentioning parent relationships, but it does not state alternatives or give explicit exclusions. An agent must infer that modifications belong to update_category.

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

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

Annotations only provide readOnlyHint=false and other false hints, so the description carries the burden of behavioral disclosure. It adds meaningful context: members are matched by name, the user is the default payer, equal split unless amounts are given, and optional account logging. These go beyond the annotations and help the agent understand side effects.

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

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

The description is three sentences, front-loaded with the main purpose, and each sentence adds distinct value: the first states what it does, the second explains matching and payer default, the third explains optional account logging. No waste or redundancy.

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

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

For a tool with 10 parameters and an output schema, the description covers the non-obvious semantics (split logic, payer default, account logging) and does not need to describe return values. It omits standard fields like date/note/category but those are self-explanatory, so the description is adequate for correct invocation.

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

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

Schema description coverage is 60%, so the baseline is 3. The description adds value for split_among (equal split default), paid_by (default you), and account_id (only when you paid), but does not clarify date, note, title, or category_id. It enriches some parameters but does not fully compensate for the uncovered ones.

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 'Add' and resource 'expense to a group', and clearly explains the core semantics (who paid, who shares). It distinguishes itself from sibling add_* tools like add_category or add_holding by focusing on group expenses, making the purpose unambiguous.

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

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

The description implies usage for group expenses but does not explicitly mention alternatives or exclusions. It does not say, for example, to use log_transaction for non-group expenses or add_planned_expense for future ones, leaving the agent to infer the appropriate context.

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

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

Annotations already mark this as a write operation with readOnlyHint=false and destructiveHint=false, so the description does not need to restate safety. It adds the auth-like constraint 'a group you are in', which is useful context. It does not disclose duplicate-member behavior, failure modes, or permission requirements beyond membership, but the annotation coverage lowers the burden.

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

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

The description is a single sentence that front-loads the action, resource, parameter, and scope without filler or redundancy. It earns its place and is appropriately concise for a simple two-parameter mutation.

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 only two required parameters and an output schema, the description plus schema is mostly complete: the agent knows what to do, which parameters to provide, and the membership constraint. It lacks edge-case behavior such as handling duplicate members or nonexistent names, but those are not necessary for correct initial invocation. A little more contrast with group_invite would make it fully complete.

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

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

The schema documents 'group' as 'Group id or name' but leaves 'name' undocumented. The description adds that 'name' refers to the member's name, which is a small semantic contribution beyond the schema. It still does not clarify whether the member must already exist or what identifier format is expected, so it only partially compensates for the 50% schema coverage.

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

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

The description uses a clear action verb ('Add'), a specific resource ('a member by name'), and a scope condition ('to a group you are in'). This makes the tool's purpose immediately understandable and distinguishable from the many finance/group tools. It does not explicitly name a sibling alternative like group_invite, so it stops just short of a full 5.

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

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

The phrase 'a group you are in' provides a clear eligibility condition, which gives some usage context. However, the description gives no explicit when-to-use or when-not-to-use guidance, and it does not contrast this tool with adjacent siblings such as group_invite. Usage context is implied rather than fully specified.

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

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

The description adds meaningful behavioral context beyond the generic annotations: it states the holding is created empty ('no lots yet') and that a live-price source is picked from the kind unless explicitly given. It could say more about duplicate/conflict behavior, but the annotations already cover the basic safety profile and nothing is contradicted.

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

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

The description is two sentences with the core purpose front-loaded. Every clause earns its place by either defining the tool's scope or routing to the correct alternative, with no filler or repetition.

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

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

With an output schema present and several parameters already described in the input schema, the description is largely sufficient. Minor gaps remain around duplicate holdings and the optional account_id behavior, but these are secondary given the schema and sibling context.

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

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

Schema description coverage is 50%, and the description adds only modest parameter-level insight: it enumerates kind values in prose and clarifies the quote_provider default behavior. It does not explain account_id, quote_symbol, or symbol beyond what the schema already provides, so it is adequate but not rich.

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

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

The description uses a specific verb and resource: 'Create an investment holding' and immediately clarifies the object type (stock, ETF, mutual fund, gold, crypto). It also explicitly distinguishes itself from record_lot and import_holdings, so an agent can tell what this tool does versus those siblings.

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

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

It directly says to use record_lot for buys/sells and import_holdings for broker exports, giving clear exclusions. 'With no lots yet' also frames the tool's role as initial holding creation, so the agent knows when it is and is not appropriate.

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

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

The description adds a meaningful behavioral detail: EMI is computed if term_months is omitted, and pay-as-you-go loans do not need term_months. It does not contradict the annotations, which only carry generic flags. However, it does not explain default schedule resolution, what happens on missing required fields, or any mutation consequences beyond what the name 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 short and front-loaded, with no filler. The two sentences carry distinct and useful information. It loses a point because the opening sentence reads more like a definition of a loan than an instruction for the add action, which slightly reduces its directness.

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 14-parameter creation tool, this description is materially incomplete. It does not state the action, required inputs, the exact schedule semantics, or how the EMI defaults interact with the required fields. The output schema exists but does not compensate for the missing invocation-level 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 43%, so the description must compensate for many undocumented parameters. It sheds light on term_months and EMI, but it leaves required fields like name, direction, principal, and currency mostly unexplained, and it introduces a 'pay-as-you-go' phrase that only loosely maps to the schema's 'flexible' enum. This is partial compensation for a low-coverage 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 identifies the resource as a loan and makes the borrowed-vs-lent direction central, which is the key semantic of the tool. It does not explicitly say 'adds/create a loan', but the tool name and title supply the action, so an agent can infer the purpose. It is clearly distinguished from update/delete tools by the add_* prefix.

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

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

There is no guidance on when to use add_loan versus sibling tools like update_loan or record_loan_payment. The description gives a useful rule about EMI vs pay-as-you-go loans, but that is input configuration guidance, not tool-selection guidance. No alternatives or exclusions are mentioned.

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

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

Annotations only indicate mutability (readOnlyHint=false) but provide no lifecycle detail. The description adds that the expense is shown under Upcoming until logged or skipped, and that amount must be positive. This is useful behavioral context beyond what annotations or schema state.

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

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

Two sentences with zero filler. The core concept is front-loaded and the caveat about positive amount is included without redundancy.

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

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

For a creation tool, the description explains the purpose and lifecycle adequately. An output schema exists, so return details are covered. Missing explicit parameter semantics is a minor gap but does not undermine core usability.

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 57%, but the description adds no parameter-level guidance beyond restating that amount is positive (already in schema). It fails to clarify name, note, category_id, or how account_id interacts with target_date. The moderate coverage is not compensated, leaving ambiguity for agents.

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

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

The description clearly states the tool adds a one-off planned expense with concrete examples (flight, fee, gift), explains it appears under Upcoming until resolved, and distinguishes it from recurring or regular transactions. It is specific and unambiguous.

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

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

The phrase 'a one-off you know is coming' implies usage for non-recurring future expenses and differentiates from add_recurring_rule. It also hints at lifecycle ('until it is logged or skipped'), pointing to resolve_planned_expense. However, it doesn't explicitly name alternatives or provide exclusion criteria, so it falls short of a perfect score.

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 are minimal (all hints false), so the description carries the burden. It explains the two modes (autoPost vs remind) and their behaviors, and clarifies the sign/currency convention. However, it does not disclose other behavioral aspects like reversibility, required permissions, or side effects on existing rules. The core behavior is covered, but not exhaustively.

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

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

The description is two sentences with zero fluff. It front-loads the purpose and examples, then details the sign convention and modes. Every sentence earns its place, and it is concise enough to be quickly parsed by an agent.

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

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

For an 11-parameter tool with an output schema, the description covers the core semantics (recurring, sign, modes) but omits details on frequency options, interval defaults, and end-date behavior. Some of these are partially addressed by schema descriptions, but the tool is complex enough that more context would be beneficial. The description is adequate but not comprehensive.

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

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

Schema description coverage is 45%, so the description must compensate for undocumented parameters. It adds meaning for 'amount' (sign) and 'mode' (autoPost/remind), but does not explain other parameters like 'interval', 'end_date', 'frequency', or 'account_id'. While some parameters already have schema descriptions (start_date, category_id), the description only partially fills the gap for the many undocumented ones.

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

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

The description clearly states the tool sets up recurring payments, with specific examples (rent, salary, subscription, EMI) that distinguish it from one-time planned expenses or reminders. The verb 'Set up' and resource 'something that repeats' are specific, and the sign convention for amounts is explicitly defined, making the tool's purpose unambiguous even among siblings like add_planned_expense.

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

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

The description implies usage for recurring items via examples but does not explicitly contrast with alternatives such as add_planned_expense (one-time) or add_reminder (not a payment). It gives clear context ('repeats') but no explicit when-not-to-use guidance or naming of sibling tools. This leaves the agent to infer the 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?

Annotations already declare readOnlyHint=false, indicating a write operation, and the description adds behavioral context: the note appears under 'Upcoming' and has no money attached. This goes beyond the annotations, but it does not disclose side effects, idempotency, or what happens if the date is in the past. The description adds some value without contradicting annotations.

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

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

The description is a single concise sentence that front-loads the core purpose ('A dated note under Upcoming') and then adds examples and a differentiator. It wastes no words and is easy to scan. Slightly more detail on parameters would be helpful, but the structure itself is efficient.

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

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

The tool has 3 parameters, 2 required, and no schema descriptions. The description does not explain the meaning of 'title,' 'date,' or 'note' clearly enough for an agent to populate them correctly without additional inference. While an output schema exists, the input guidance is lacking, making the description incomplete for a reliable call.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only hints at 'date' and 'note' via 'dated note' and examples, but does not clarify the 'title' parameter or the exact format of 'date' and 'note.' The examples show note content (renew passport, cancel trial) but not the title. This is insufficient given the lack of schema descriptions.

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

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

The description states a clear action: it adds a dated note under the 'Upcoming' section, with examples of typical use (renew passport, cancel trial). It differentiates from monetary tools like add_planned_expense by explicitly saying 'No money attached.' While not as explicit as 'creates a reminder,' the verb 'add' is implied by the context.

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

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

The description implies usage for non-monetary dated notes through examples and the 'No money attached' note, but it does not explicitly state when to use this tool over alternatives like add_planned_expense or add_recurring_rule. It provides context but no exclusions or explicit guidance on selection criteria.

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 the tool read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond those hints: the calendar-month window, per-currency grouping, and the ratio > 1 over-budget threshold. It does not contradict the annotations.

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

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

One sentence communicates the scope, grouping, and interpretation of the output with no filler. The over-budget ratio definition is a concise and valuable addition at the end.

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 report with zero required parameters, an output schema, and strong annotations, the description covers the essential invocation semantics: month, currency grouping, and ratio interpretation. Minor gaps like currency format are not blocking since currency is optional.

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

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

The schema documents 'month' format and default, but 'currency' has no description, leaving 50% schema coverage. The phrase 'per currency' clarifies that currency is a meaningful grouping/filter dimension, but it doesn't explain the currency format or what happens when the parameter is omitted.

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

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

The description clearly identifies a budget-status report: it returns budgets with category/sub-category consumption for the current calendar month, per currency, and defines what an over-budget ratio means. This distinguishes it from generic spending tools like spending_summary or spending_trend, though it doesn't name them or use an explicit imperative verb.

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

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

No guidance is given about when to use this tool rather than alternatives such as spending_summary or set_budget. The intended use is inferable from the name and content, but the description provides no explicit usage context or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavioral details: it returns a PNG image and also includes the figures as a table for exact quoting. It also states the currency handling rule (never summed across). These go beyond annotations and help the agent set expectations without contradiction.

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

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

The description is two sentences, front-loads the core purpose, and every clause adds information: what it produces, the chart kinds, currency scoping, and the table output. No fluff or redundancy.

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

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

Given the 7 parameters and an output schema, the description covers the main use cases and output format. It mentions the table return and the currency rule, which are key. It doesn't detail per-kind parameter usage, but the schema descriptions already do that. The output schema documents return values, so the description is sufficiently complete for an agent to decide when and how to call it.

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

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

Schema coverage is 86%, so most parameters are already described. The description adds a little extra meaning—'One panel per currency' explains the currency parameter behavior, and 'top categories' hints at the top parameter. However, it does not systematically explain parameter interplay (e.g., which kinds use from/to). With high 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 clearly states the tool's purpose: it produces a PNG chart of financial data, listing four specific chart kinds (spending by month, income vs spending, top categories, balance over time). It also clarifies scope (one panel per currency) and output (also a table). This distinguishes it from sibling text-based tools like spending_summary.

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

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

The description implies usage—when the user needs a visual chart—but does not explicitly name alternatives or provide when-not-to-use guidance. It says 'as a PNG you can show the user', which suggests user-facing scenarios, but it doesn't contrast with spending_summary, spending_trend, or net_worth. Usage context is inferable but not explicit.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows it is a mutation. The description adds the detail that it can either mark done or delete, but does not explain side effects, reversibility, or what happens on success. It does not contradict annotations, but adds limited behavioral context.

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

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

A single sentence with no filler. The primary action is front-loaded, and the alternative is mentioned in a parenthetical. Extremely concise and to the point.

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

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

For a destructive mutation with an output schema, the description is too sparse. It does not explain prerequisites, error conditions, or the precise behavior of the delete parameter. Given the tool's destructive nature, more context is needed to ensure correct usage.

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

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

Schema coverage is 0%, so the description must explain the parameters. It mentions 'delete it', hinting at the delete boolean, but does not explicitly map 'id' to the reminder or clarify that 'delete' toggles between complete and delete. An agent might not know the semantics without inspecting the schema.

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

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

The description states a specific verb 'Mark' with a clear resource 'reminder' and an explicit alternative 'or delete it'. This clearly distinguishes it from sibling tools like add_reminder, as it is the only tool that acts on existing reminders to complete or delete them.

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

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

No explicit when-to-use guidance is given. It is implied that this tool is for completing or deleting reminders, but there is no mention of alternatives or conditions (e.g., when to use delete vs. complete). The agent must infer from the name and description.

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

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

Annotations already declare destructiveHint=true, so the agent knows this is a mutation. The description adds what gets changed, but does not go further into consequences like irreversibility, effects on splits/transfers, or approval needs. With annotations already carrying the safety profile, this is adequate but not rich.

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

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

Two sentences with no filler. The core scoping distinction is front-loaded in the first clause, and the usage trigger is in the second. Every word earns its place.

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

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

For a 4-parameter tool with an output schema and destructive annotation, the description gives strong selection and field-scope guidance. Minor gaps remain around date format and the implied requirement to provide at least one mutable field, but the schema and output schema cover much of the invocation detail.

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%, with amount and account_id already documented. The tool description confirms date and account are modifiable, but it does not clarify date format or specify that at least one of date/amount/account_id should be supplied alongside id. It partially compensates for the schema gap, but not fully.

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 ('Change'), names the exact resources affected (amount, date, account), and explicitly distinguishes itself from update_transaction by noting it covers what that sibling 'deliberately leaves alone.' An agent can immediately tell this apart from update_transaction 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 an explicit trigger condition ('Use when the user says the number itself was wrong') and names the alternative tool it should be compared against. This is direct, actionable routing guidance rather than a generic description.

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

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

Annotations already indicate this is a mutating operation (readOnlyHint=false) and not idempotent, so the description does not need to restate that. It adds one useful behavioral rule: 'One currency per account.' However, it does not disclose side effects such as whether the account is immediately usable, how opening_balance interacts with account creation, or any validation failure behavior. The added constraint earns some credit but the transparency is thin.

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, with no filler or redundant elaboration. The core action is front-loaded and the currency constraint follows directly. It is concise, but it is also minimal to the point of omitting valuable guidance, which keeps it from a 5.

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 8 parameters, 3 required fields, enum values, and an output schema, the description only states the action and one constraint. It leaves the agent to infer required fields, account type options, and the significance of opening_balance. While the schema and output schema provide some structured context, the description does not fill the gaps for a non-trivial creation operation.

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

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

Schema description coverage is only 50%, so the description must compensate for undocumented parameters. It does not. The only semantic guidance is 'One currency per account,' which partially explains the currency parameter. It says nothing about name, type, opening_balance, as_of, last4, region, or institution. The schema itself documents a few fields, but the description adds no meaningful parameter-level detail beyond the currency constraint.

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

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

The description states the specific verb and resource: 'Create an account.' The added constraint 'One currency per account' gives a meaningful business rule that differentiates the act of creation from generic setup. It is not a tautology, though it relies on the tool name for the core action. It clearly distinguishes from sibling tools like update_account and set_account_balance, which imply modification rather than creation.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_accounts, update_account, or set_account_balance. It does not mention prerequisites, typical scenarios, or when a user should call a different tool. The usage context is only implied by the word 'create' and the sibling list.

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

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

Beyond the annotations (not read-only, not idempotent, not destructive), the description adds meaningful behavioral context: the caller becomes owner and members are set by name at creation, while later joining happens via group_invite. It does not detail duplicate handling or failure behavior, but the annotations and output schema cover the key safety profile.

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

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

Two short sentences, with the main purpose front-loaded and examples in parentheses. No filler or repeated schema content.

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

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

With an output schema present and annotations covering safety, the description is sufficient for selecting and invoking the tool. It provides the essential ownership and member-joining context; only the absence of explicit guidance about existing groups and the currency meaning 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 low (25%). The description clarifies that 'members' are the other members' names and implies 'name' is the group ledger's name, but it does not explain the required 'currency' parameter or the optional 'note'. This is partial compensation rather than full 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 starts with the specific action 'Start a group ledger' and gives concrete examples (a trip, a flat). It explicitly assigns the owner role to the caller and distinguishes this creation tool from group_invite, so the agent can tell it apart from sibling tools.

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

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

It clearly states when to use this tool: when starting a new group ledger with the caller as owner and naming members. It also points to group_invite as the alternative for later joining, though it does not explicitly contrast with add_group_member for adding members to an existing group.

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 state mutability (readOnlyHint=false) and non-idempotency. The description adds valuable behavioral detail: 'the rate is frozen at creation', 'Legs are excluded from spending', and 'an optional fee is a real expense'. These explain accounting effects that are not apparent from the schema. No contradiction with annotations; the extra context is significant but not exhaustive (e.g., no mention of balance updates or constraints on accounts).

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, each carrying distinct information: the core action, the currency-handling nuance, and the accounting treatment. No filler or redundancy; all content earns its place.

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

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

Given the tool's complexity (currency conversion, fee, leg accounting) and that an output schema exists, the description covers the most critical behaviors. It explains the rate freezing, spending exclusion, and fee expense—aspects that would otherwise be surprising. It omits minor details like whether from_amount is the source-currency amount, but these are inferable from the schema's required field and the 'source currency' note on fee. Overall, the description is sufficiently complete for correct invocation.

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

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

Schema description coverage is low (25%), so the description must compensate. It does clarify the roles of rate and to_amount ('For different currencies give to_amount or rate') and the fee ('an optional fee is a real expense'). However, it does not explain date, note, from_amount, or account IDs beyond what the schema's type/required fields imply. This partial compensation is helpful but incomplete.

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

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

The description 'Move money between accounts' uses a specific verb and resource, clearly distinguishing this from create_account, delete_transfer, and log_transaction. The scope is explicit and unambiguous.

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

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

Provides clear guidance for different-currency transfers: 'For different currencies give to_amount or rate; the rate is frozen at creation.' This tells the agent when to supply which parameters. It doesn't explicitly contrast with log_transaction for income/expense, but the purpose statement implies the use case, so the guidance is adequate though not exhaustive.

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?

Even though annotations already mark the tool as destructive, the description adds concrete side effects beyond structured data: 'every member's phone drops it' and 'The payer's own bank row, if any, is removed too.' This meaningfully discloses cascading deletion behavior.

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

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

The description is two tight sentences with no filler. The core action is front-loaded, and the parenthetical packs an important side effect into a compact, readable clause.

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

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

The description adequately covers purpose and side effects, and an output schema exists so return values need not be described. However, with zero required parameters and zero schema descriptions, the missing guidance on which ID to provide for which deletion case leaves the invocation semantics incomplete.

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

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

Schema description coverage is 0%, so the description must compensate, but it only echoes the two parameter types ('expense' and 'settlement') without explaining how to populate expense_id or settlement_id or that exactly one is likely required. The agent is left guessing about ID selection and requiredness.

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

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

The description opens by naming the exact resource and action: 'Delete a group expense or a group settlement.' This specifically distinguishes it from sibling delete tools like delete_transaction, delete_transfer, and delete_split by the 'group' scope, while also noting the payer's bank row is removed.

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

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

The description clearly states the intended use case: deleting a group expense or a group settlement. It does not explicitly mention alternatives or when not to use it, but the group-resource framing gives enough context for an agent to pick this over nongroup deletion 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 destructiveHint=true and readOnlyHint=false. The description adds valuable context beyond that: the deletion takes effect on the phone's next sync, which is a non-obvious behavioral trait. This helps set expectations about the timing of the effect, so the description adds meaningful behavioral detail.

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

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

The description is a single sentence with a useful parenthetical explanation. Every word adds value, and the core action is front-loaded. There is no redundancy.

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

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

For a simple destructive action with one parameter and an output schema present, the description covers the key behavioral nuance (sync timing). It does not explain error cases or undo possibilities, but destructiveHint already signals permanence, and the output schema likely covers return values. Overall it is adequately complete for the tool's complexity.

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

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

Schema coverage is 0%, so the description carries the burden of explaining parameters, but it does not mention 'id' at all. The parameter name alone suggests it is the identifier of the parse rule, but the description neither confirms this nor advises how to obtain a valid id. Given the low schema coverage, this is a notable 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 clearly states the specific action ('Remove one of your parse rules') and the resource (parse rules). This distinguishes it from sibling tools like save_parse_rule, test_parse_rule, and list_parse_rules, which clearly serve different purposes.

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: use this to delete a parse rule. However, the description does not explicitly mention alternatives or prerequisites (e.g., finding the rule ID via list_parse_rules, or conditions that must hold before deletion). The context signals suggest there are no true alternatives for this action, but the description could still guide when not to use it.

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

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

Beyond the destructiveHint annotation, the description adds crucial behavioral details: that removing a split leaves the transaction intact, and that deleting a settlement also removes its associated bank row if one exists. These specifics are not captured in annotations and materially affect agent decisions.

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, well-structured sentence that front-loads the primary action and uses a semicolon to separate the two modes. No wasted words, and the key behavioral caveat ('the transaction stays') is included without clutter.

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

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

The tool has an output schema, so return values are already specified. The description covers the two operational modes and their side effects, but doesn't clarify whether both parameters can be provided simultaneously (though the 'or' implies mutual exclusivity). This is a minor gap given the overall clarity.

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

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

Schema coverage is 0%, so the description must convey parameter meaning. It does so by associating split_id with the split-removal action and settlement_id with the settlement-deletion action, though it doesn't explicitly name the parameters. This is sufficient for an agent to infer which parameter to use for each mode.

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 two distinct actions: removing a split from a transaction (explicitly noting the transaction remains) and deleting a settlement by id. It uses specific verbs ('remove' and 'delete') tied to specific resources, and it differentiates from siblings like delete_transaction and delete_transfer by scoping to splits and settlements.

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

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

The description implies usage context: use this when you need to remove a split without affecting the transaction, or when you need to delete a settlement. It doesn't explicitly name alternatives or when-not-to-use, but the 'or' structure and clear resource distinction provide sufficient guidance for an agent to decide.

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

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

While annotations already mark this as destructive and non-idempotent, the description adds key behavioral detail: deleting a transaction cascades to its splits, and transfer legs are explicitly excluded and require deleting the transfer instead. This tells the agent exactly what gets destroyed, going beyond the annotation flags.

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

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

Two short sentences with no filler. The core action is front-loaded, and the important caveats about splits and transfer legs follow immediately. Every word earns its place.

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

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

For a single-parameter destructive tool with an output schema and strong annotations, the description covers the essential action, the cascade behavior, and the transfer exception. There are no significant gaps that would prevent an agent from calling the tool correctly.

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

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

Schema description coverage is 0%, and the description never mentions the `id` parameter explicitly or explains how to obtain it. The phrase 'a transaction' implies the id identifies a transaction, but the description does not compensate for the complete lack of schema documentation on the 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 and resource: 'Delete a transaction', and immediately clarifies scope by noting that any split on it is also deleted. It also distinguishes itself from transfer-related tools by saying transfer legs should be handled differently. This gives an agent a precise mental model of what the tool does.

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

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

Provides a clear when-not-to-use instruction: for transfer legs, delete the transfer instead. It also implies that this tool is for deleting whole transactions (including splits), contrasting with split-level tools. The alternative behavior is explicit enough for an agent to route correctly.

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

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

Annotations already mark this as destructive, but the description adds valuable detail beyond that: it specifies that both legs and any fee row are removed. This is exactly the kind of behavioral nuance an agent needs before invoking a destructive 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?

One concise sentence with no filler. The core effect is front-loaded, and the conditional fee-row note is packed efficiently without being verbose.

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

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

For a simple one-parameter delete operation with a destructive annotation, the description fully conveys the scope and consequences. The output schema exists, so return-value details are not needed, and no other invocation-critical information is missing.

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

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

Schema description coverage is 0%, and the description does not explicitly explain that 'id' is the transfer's identifier or what format/value it should take. The single required id parameter is left to be inferred from the tool name and context.

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

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

The description uses a specific verb ('Remove') and resource ('a transfer'), and adds important scope by naming both legs and the optional fee row. This clearly differentiates it from sibling tools like delete_transaction and delete_split.

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 cascade behavior implies this is the tool to remove an entire transfer, including its legs, but it never explicitly says when to prefer it over alternatives such as delete_split or delete_transaction. The intended usage is clear but 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?

Annotations only declare readOnlyHint false, implying mutation, but the description adds meaningful behavior: it explains that with member_id the invitee becomes a named placeholder preserving history, otherwise they join as a new member. This goes beyond annotations and discloses the key side effect of creating an invite link, though it does not mention expiration or other potential side effects.

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

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

Two sentences with no filler. The core purpose is stated first, followed by the conditional behavior. Every word earns its place, and the structure is front-loaded.

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

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

Given the tool's simplicity, the description covers the two operating modes and their outcomes. An output schema exists, so return values are defined elsewhere. Minor gaps like prerequisites or invite-link lifecycle are not critical for a straightforward tool like this.

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

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

Schema coverage is 0%, so the description must compensate. It explicitly explains the meaning of member_id and its two states. group_id is not directly described, but its purpose is obvious from the context and title. The description adds value for member_id but leaves group_id to inference.

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

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

The description clearly states the tool creates an invite link for a group and distinguishes two modes based on member_id. This is specific enough to differentiate from sibling tools like add_group_member, which adds members directly, and the title reinforces the action.

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

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

The description provides clear guidance on when to use member_id (to assign a placeholder) versus not (to add a new member). However, it does not explicitly mention when to choose this tool over alternatives like add_group_member or settle_group, though the invite-link concept implies a different use case.

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

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

The description goes well beyond the annotations by disclosing the full effect on holdings and lots, duplicate handling, the dry-run default, and the commit requirement. It also explains why the behavior matters ('so cost basis and P/L work from day one'), which helps the agent anticipate downstream consequences.

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

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

Three dense sentences deliver the core purpose, default behavior, and side-effect semantics without filler. The most decision-relevant facts (duplicates skipped, dry-run unless commit) are front-loaded and each sentence earns its place.

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

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

For a 7-parameter mutation tool with 86% schema coverage and an output schema, the description covers the non-obvious behaviors: CSV format, lot creation, duplicate handling, replace semantics, and commit gating. An agent has what it needs to call the tool correctly.

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

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

The schema already documents most parameters with 86% coverage, so the baseline is high. The description adds real value beyond the schema by defining the expected CSV columns (instrument, quantity, average cost, optionally LTP), how as_of becomes the lot date, and how replace affects existing holdings.

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

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

The description names a specific action ('import a broker's holdings export') and a specific destination ('into an investment account'), with enough CSV detail to distinguish it from one-off tools like add_holding or import_statement. The row-to-holding-and-buy-lot behavior makes the purpose concrete and unambiguous.

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

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

The description clearly states what this tool is for and gives important invocation context: it handles broker exports, creates opening lots, skips existing holdings unless replace=true, and dry-runs unless commit=true. It does not explicitly say when to use a sibling tool instead, but the context is clear enough for an agent to select it among the many 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?

The description adds substantial behavioral context beyond annotations: the default is non-writing, commit has the side effect of writing rows into the review queue, and each row is returned as ready/duplicate/invalid. It also communicates currency handling ('Amounts are read in the account's currency'), which is not visible in the structured annotations.

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

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

The description is short and front-loaded, with no filler. It packs the main action, default behavior, commit behavior, and currency rule into four focused sentences. Every sentence adds information not already in the schema 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 tool with an output schema, the description is almost complete: it explains default behavior, commit flow, statuses, and the review queue. It does not specify how CSV rows are parsed into categories or how duplicates are detected, but the dry-run statuses and output schema make the tool safely usable initially.

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

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

The schema describes csv, commit, and include_duplicates, but the description adds meaning: commit=true writes ready rows into the review queue, and the dry-run result contains every parsed row with a status. It also adds a currency interpretation for the csv data that the schema does not provide. Only account_id remains generic, though 'into one account' implies its purpose.

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

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

The description opens with a specific action and resource: 'Import a bank statement (CSV text) into one account.' It clearly distinguishes this tool from others like import_holdings by stating the resource type and scope. It also clarifies the two modes (dry-run vs commit), removing ambiguity about what the tool does.

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

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

The description explicitly states the default behavior ('Dry-run by default') and the condition for writing ('Pass commit=true to write the ready rows'), which tells an agent when previewing vs committing is appropriate. It does not name alternatives or exclusions such as when to use record_card_statement or import_holdings, so it stops short of full alternative-based 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 convey read-only, idempotent, non-destructive behavior. The description adds useful scope (accounts owned by the user plus partner-shared ones) and says the balance is current, but does not discuss response volume, auth, or rate limits; given the strong annotations, this is adequate but not rich.

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

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

The description is a single 16-word sentence with no filler. The topic 'Accounts' is front-loaded and every clause adds relevant information about returned attributes and access scope.

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 no-parameter read-only list with rich annotations, an output schema, and no nested objects, the description covers the returned fields and access scope well. It does not explicitly state 'returns all accounts' or mention sorting, but nothing required to invoke the tool successfully appears missing.

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

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

The tool has zero parameters, so there is no parameter-level meaning for the description to add; the baseline for 0-parameter tools is 4. The description appropriately clarifies output scope instead.

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 (accounts) and enumerates the returned attributes, including partner-shared accounts, which distinguishes it from sibling tools like list_holdings and list_categories. However, the description itself lacks an explicit verb such as 'list' or 'retrieve', relying on the title for the action.

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

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

No when-to-use guidance or comparison with alternative tools is provided. The only indication of intended use comes implicitly from the name/title, with no exclusions or prerequisites 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, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds useful context about the data model — that categories have a kind (expense/income) and that sub-categories have parents. However, it does not disclose ordering, whether top-level categories are included, or behavior on empty results; these gaps are minor for a parameterless read-only 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?

A single sentence that is efficient and front-loaded with the most relevant information. The phrase 'Category ids, names, kind... and parent' is a fragment lacking a verb (e.g., 'Returns...'), which makes it slightly awkward to parse as a description, but it contains no waste.

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

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

Given zero parameters, an existing output schema that documents return fields, and rich read-only annotations, the description is largely adequate. The only notable gap is the ambiguity of whether top-level (non-sub) categories are also returned, since the description emphasizes sub-categories via the 'parent' field. This is a minor omission for such a simple 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?

The tool has zero parameters, so the baseline is 4 per the rubric. There are no parameters for the description to explain, and the schema carries no burden in this dimension. The description adds no parameter information, but none is needed.

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

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

The description names the resource (categories) and specifies the returned fields (ids, names, kind, parent), which tells the agent what data to expect. The action itself ('list') is carried by the title rather than the description, and the description reads as an output-field enumeration rather than a purpose statement. It does not explicitly differentiate from siblings, though the list vs. add/update contrast is self-evident.

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

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

No guidance on when to use this tool versus alternatives. The description mentions 'parent for sub-categories,' which hints at the data model, but there is no when-to-use, when-not-to-use, or mention of related tools such as add_category, update_category, or set_category_rule. An agent must infer the intended use entirely from the title and sibling names.

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

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

The annotations already cover readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond that: the tool reports balances from the card account rather than a unified account, defines outstanding as a simple principal minus payments calculation, and notes per-currency grouping. This enriches the agent's understanding of response semantics.

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

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

The description is a compact two-sentence definition with no filler. It front-loads the main resource and immediately provides clarifying details in parentheses. Every clause carries information.

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

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

Given an output schema is present, the return structure needs no explanationchedron. The description covers the main content well but falls short on the one input parameter, include_closed, leaving a gap that is significant for correct invocation, especially since the schema itself provides no 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?

There is one parameter, include_closed, with 0% schema description coverage, and the description does not mention it at all. The parameter name hints at filtering closed items, but the description provides no clarification of what 'closed' means or what the default behavior is, so the agent must guess.

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: lists credit cards and loans. The description breaks out exactly what is included for each (card limit, cycle, current balance; loan borrowed/lent, payments, outstanding), distinguishing it clearly from siblings like list_accounts and list_holdings.

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

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

The description makes clear what data is covered, so an agent can infer when to call it versus other list tools, but there is no explicit 'when not to use' or reference to alternatives. The usage context is implied by the resource scope, not directly 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the returned data structure (members, per-currency totals, net positions, settlement payments), which goes beyond the schema. No contradictions or missing behavioral warnings are apparent.

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

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

The description is a single, well-structured sentence that front-loads the resource ('Your expense groups') and packs all essential details without redundancy. Every clause adds relevant information, and there is no fluff or unnecessary wording.

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 with one optional parameter and an existing output schema, the description sufficiently explains what the tool returns and from whose perspective. It does not mention sorting, pagination, or group filtering nuances, but these are minor for this simple operation. The presence of an output schema reduces the burden on the description for return-value 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?

The single optional parameter 'group' is fully documented in the schema with a clear description ('Name or id; omit for all'), and schema description coverage is 100%. The tool description adds no extra parameter semantics, so the baseline score of 3 applies.

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

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

The description uses a specific verb (list) and clearly identifies the resource (expense groups), then enumerates the returned content: members, per-currency totals, net positions, and settlement payments. This distinguishes it from sibling list tools like list_accounts or list_transfers, and clarifies it is not just a basic group listing.

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 purpose—listing the user's expense groups—but provides no explicit guidance on when to use it instead of alternatives like people_balances or settle_group. There are no when-not-to-use conditions or references to sibling tools, so usage 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description is not responsible for those. It adds valuable context about quote freshness ('never assume they are live') and the per-currency grouping, which are not in the annotations. This exceeds the minimum bar set by annotations.

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

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

Two short, focused sentences. The primary purpose and key data caveat are front-loaded, with no filler. Every sentence adds value and is directly relevant to invocation.

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

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

The description covers the output data shape and the quote staleness warning, but it omits any explanation of the include_archived parameter. Since an output schema exists, return format need not be detailed, but parameter semantics are a notable gap. For a simple tool, this is acceptable but not fully complete.

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

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

The schema has one parameter, include_archived, with no description in the schema (coverage 0%). The tool description does not mention this parameter at all, leaving the agent to guess its meaning and default behavior. With zero schema coverage, the description must compensate, but it fails to explain the parameter or its effect.

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

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

The description clearly states the tool lists investment holdings with specific fields (quantity, cost basis, last cached quote, unrealised P/L) and groups them by currency. This is a specific verb-resource pair that distinguishes it from sibling list_* tools like list_accounts or list_categories.

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

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

The description implies usage through the resource name but does not explicitly mention when to use this versus alternative tools (e.g., import_holdings, update_holding). No exclusions or alternatives are stated, leaving the agent to infer context from the name and sibling set.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds useful domain context by explaining what parse rules are, though it does not disclose any behavioral traits beyond what the annotations already provide.

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

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

One sentence with no wasted words, and the key clarification—bank-alert patterns learned through MCP—is front-loaded. It earns its place by explaining the domain without padding.

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

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

For a parameterless, read-only list with an output schema and complete safety annotations, the description is nearly complete. The only minor gap is explicit routing guidance among the parse-rule sibling tools, but that does not hinder a correct call.

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

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

The tool has zero parameters, so there is no schema burden for the description to compensate for. The description adds meaning by defining the term 'parse rules,' which is sufficient for a parameterless invocation.

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

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

The description identifies the resource as saved parse rules and clarifies they are bank-alert patterns learned through MCP, which distinguishes them from transaction parsing or recurrence rules. It relies on the title for the verb 'list,' but the resource scope is unambiguous.

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

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

There is no guidance about when to use this tool versus related parse-rule tools such as save_parse_rule, delete_parse_rule, or test_parse_rule. The read-only listing intent is implied by the name and annotations, but no explicit when-to-use or alternative guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is fully covered. The description adds what the result contains, but it does not disclose how include_paused affects the returned set; this is acceptable for a safe read operation with an output schema, though not rich.

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

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

A single, short sentence with no filler or repetition. It could be improved by making the action explicit and mentioning the include_paused caveat, but it is 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?

For a simple optional-parameter list with annotations and an output schema, the core information is present. The main gap is the unexplained include_paused parameter and the lack of any comparison with related recurring-rule or upcoming tools, leaving some ambiguity for an agent.

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

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

Schema description coverage is 0% and the description never explains include_paused. The parameter name alone suggests it controls whether paused rules are included, but the default behavior and exact boolean semantics are left ambiguous.

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 (recurring rules) and the displayed fields (next run, mode, paused state), so an agent understands what the tool exposes. However, it is a noun phrase rather than an explicit action and does not differentiate itself from add_recurring_rule or update_recurring_rule beyond the list-style title.

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

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

No guidance is given on when to use this tool versus alternatives such as add_recurring_rule, update_recurring_rule, or upcoming. The read-only nature is only implied by the name and title, with no explicit context or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'effective rate' detail, which hints at what is included in the results, but it does not disclose pagination, ordering, date filtering behavior, or whether the 'to' and 'from' parameters are required for scoping. The description does not contradict the annotations.

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

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

The description is extremely short and front-loaded, with no wasted words. However, it is under-specified rather than efficiently concise; the single phrase 'Transfers with their effective rate.' is grammatically incomplete and omits essential operational context. It earns a 4 for brevity but loses a point for being too sparse to be genuinely 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?

Given the tool has two undocumented parameters, no output schema details provided in the description, and a large sibling set with many list_* tools, the description is incomplete. The annotations cover safety, but the description does not explain what 'effective rate' means, how the parameters filter results, or what the response contains. An agent would need to inspect the output schema or guess parameter semantics.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'to' and 'from' parameters. It does not. The description only mentions 'effective rate' and gives no hint that 'to' and 'from' are likely date or account range filters. With two completely undocumented parameters and no explanatory text, the agent cannot infer their meaning from the description.

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

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

The description 'Transfers with their effective rate.' identifies the resource (transfers) and a distinguishing attribute (effective rate), but it lacks a specific verb like 'list' or 'retrieve' and does not clarify what the tool actually returns. It is distinguishable from create_transfer and delete_transfer by the resource name, but the description itself is terse and does not explicitly state the operation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_accounts, search_transactions, or create_transfer. There is no mention of context, exclusions, or prerequisites. The readOnlyHint and idempotentHint annotations imply it is a safe read operation, but the description itself offers no usage direction.

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

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

The description discloses meaningful side effects beyond the generic annotations: entries land in the review queue, category is auto-suggested from the merchant when omitted, and excluded transactions still move the balance but stay out of insights and budgets. Since annotations only carry false flags, the description carries the behavioral burden and mostly meets it.

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

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

Four compact sentences, all substantive: core purpose, category behavior, review-queue side effect, and the excluded nuance. There is no filler or unnecessary prose.

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

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

Covers the purpose, the required amount semantics, the review-queue side effect, and the non-obvious excluded behavior; the output schema can cover the return shape. It does not mention transfer/group alternatives or failure behavior, which keeps it from being fully complete.

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

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

The description adds important meaning beyond the schema: amount sign semantics, account currency, optional category_id auto-suggestion from merchant, and concrete excluded examples. This compensates for the low 44% schema coverage, though note, place, and merchant are left to inference.

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 ('Record') with an explicit resource ('an expense (negative amount) or income (positive) on an account') and even gives the sign convention for amounts. The scope clearly differentiates it from transfer and group-expense siblings without needing to name them.

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

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

Gives clear conditions for what belongs here: real expenses/income, with excluded=true for balance-only movements such as reimbursements or refundable deposits. It stops short of explicitly directing the agent to create_transfer for transfers or add_group_expense for group spending, so it lacks a full when-not-to-use 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?

Despite strong annotations (readOnly, idempotent, non-destructive), the description adds meaningful behavior beyond them: investments use the 'last quote,' amounts are 'restated at today's rate,' and unconvertible items are explicitly listed. This gives the agent an accurate model of what the tool actually does with data, which annotations do not convey.

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

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

The description is two tight sentences with no filler. The primary idea is front-loaded, the component breakdown is scannable, and the caveat about unconvertible items and per-currency exactness is placed at the end without bloating the message.

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 aggregation tool with a single optional parameter, an output schema, and strong safety annotations, the description covers the important operational details: valuation basis, scope of assets/liabilities, conversion behavior, and failure handling. An agent has enough context to call this tool correctly and interpret its purpose relative to 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%, so the single optional currency parameter is already documented in the schema. The description reinforces that the whole summary is expressed in one currency and restated at today's rate, but it does not add new parameter-specific meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly defines the tool as a consolidated net-worth snapshot, listing exactly which components are included: cash, investments, amounts owed, and amounts owing. It distinguishes this aggregate view from the many raw list/ledger siblings by emphasizing 'the whole picture in one currency.' The intent is unambiguous even though it relies on 'restated' and 'Lists' rather than a single imperative verb.

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

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

The description implies when to use this tool: when a consolidated multi-currency picture is needed. It also gives guidance to prefer other tools when exact per-currency figures are required: 'Per-currency figures stay exact in the other tools.' It does not name specific sibling tools like list_holdings or list_debts, but the routing signal is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which fully cover the safety profile. The description adds 'does NOT save' (redundant) and 'same rule engine the app uses' (context, not behavioral). No contradiction, but little extra beyond annotations.

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

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

The description is three short sentences, front-loaded with the action, then returns, then a routing hint. No wasted words, and every sentence adds value.

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

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

The description covers the core purpose, the safety (via annotations), the return fields (likely in the output schema), and provides a clear alternative for recording. The main gap is parameter semantics for account_id and sender_id (beyond schema) and a lack of differentiation from test_parse_rule, but overall it is fairly complete for a read-only parse 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 33% (sender_id has a description). The description implicitly explains 'text' as the bank SMS/email body but does not explain account_id or sender_id beyond what the schema provides. With low schema coverage, the description should compensate more for the remaining parameters but does not.

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

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

The description states a clear verb and resource: 'Run a bank SMS/email body through the same rule engine the app uses.' It also specifies the returned fields and explicitly says it does NOT save, which differentiates it from log_transaction. This is specific and unambiguous.

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

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

The description gives an explicit when-not: 'does NOT save' and directs to 'Use log_transaction to record it,' which is a clear alternative for recording. However, it does not mention other similar tools like test_parse_rule or save_parse_rule, so the guidance is partial but still useful.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: balances are per person per currency, include both splits and settlements, and define the sign of the balance. This goes beyond the annotations without contradicting them.

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

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

The description is a single, information-dense sentence that front-loads the core purpose and immediately clarifies the sign convention. There is no redundant filler or repetition of schema details.

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

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

The tool is simple: one optional parameter, full schema coverage, an output schema, and read-only/idempotent annotations. The description covers the essential semantics needed to call and interpret the tool correctly, leaving no significant gaps.

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

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

Schema description coverage is 100% and the single optional 'person' parameter is already documented as a case-insensitive name filter. The tool description adds context about per-person/currency granularity but does not add new parameter-level meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description clearly states what the tool does: it reports who owes whom from split bills, per person per currency, including splits and settlements. The phrase 'from split bills' distinguishes it from broader debt/loan tools, and the sign convention ('Positive balance = they owe you') makes the output interpretable.

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

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

The description gives clear context: it is for split-bill balances and settlements rather than general debts or loans. It does not explicitly name alternatives like list_debts, but the scope is specific enough that an agent can infer when to use it.

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

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

Annotations already mark destructiveHint=true, but the description goes further: it details the dry-run default, the exact side effects of commit=true (adding missing rows as bank-confirmed, flagging unexplained ledger rows to review queue, recording the run), and the report contents. This is rich behavioral disclosure beyond the annotations, with no contradiction.

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

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

Two sentences, no filler. The core purpose is front-loaded, and the second sentence efficiently enumerates the report and commit behavior. Every clause earns its place; the description is both concise and information-dense.

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

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

Given the tool's moderate complexity (9 parameters, mostly optional), the presence of an output schema, and the detailed annotations, the description covers what an agent needs: input formats, report items, dry-run vs commit semantics, and side effects. No critical information is missing for correct invocation.

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

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

Schema coverage is 89% (all but account_id described). The description adds semantic context for key parameters: it explains the two input modes (csv vs rows) and the effect of commit, which is not fully captured in the schema. It does not re-describe each parameter but adds meaningful usage context, elevating it above the baseline.

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

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

The description opens with a precise verb and resource: 'Reconcile one account against a bank statement for a period.' It clearly distinguishes from siblings like import_statement (which imports statements) and set_account_balance (which sets a balance) by specifying the reconciliation scope and the report output. The purpose is unambiguous.

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

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

The description explains how to supply the statement (CSV text or rows from a PDF) and the dry-run/commit workflow, which gives clear context. However, it does not explicitly name alternatives like import_statement or state when NOT to use this tool (e.g., 'for simple statement import, use import_statement instead'). The usage is clear but lacks 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?

Adds substantial context beyond the annotations: the dry-run-until-commit=true gate, side-effect on card terms (limit, statement day, due date, minimum due), the match-or-add behavior for lines, the auto-generated 'Balance adjustment' row that "never counts as spending," and replacement-on-reread. The re-send replacement nuance is consistent with idempotentHint=false (the tool is still not globally 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?

A single dense ~90-word paragraph with the core purpose front-loaded and every sentence carrying information. It is appropriately sized for a 13-parameter tool, though the mid-sentence "whatever still separates the ledger from the closing balance" phrasing is somewhat convoluted and could be tighter.

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, write-behind tool, the description covers the main workflow end to end: anchoring, terms-setting, line handling, adjustment creation, ordering, re-send, and dry-run. The output schema and 100%-covered input schema carry the remaining burden; the description could have acknowledged the accounting-only params (fees, interest, apr_percent, previous_balance) but their schema descriptions already say they are used only when lines are 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 coverage is 100%, so the baseline is 3, but the description adds real relational meaning: it identifies statement_date + closing_balance as the pair that anchors the ledger, explains that lines are matched or added against the closing balance, and positions commit as the write gate. This goes beyond the schema's literal per-field descriptions.

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

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

The opening phrase — "One credit-card statement, as the bank printed it" — names a specific resource, and the body makes the action concrete: give statement date + closing balance and the ledger is anchored to the bank. It clearly distinguishes itself from siblings like import_statement or reconcile_statement by scoping to card statements and by describing the anchoring behavior.

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

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

Gives explicit procedural guidance: "Send statements oldest first, one call each" and explains re-send semantics ("re-sending the same statement date replaces its adjustment instead of stacking"), plus the dry-run default. It does not, however, name alternatives or state when to prefer this over siblings such as import_statement or set_credit_card, so exclusions are implicit rather than explicit.

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

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

The annotations already indicate a write operation (readOnlyHint=false), and the description adds a meaningful side-effect: optionally writing the cash row when account_id is provided. It does not contradict the annotations and provides 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?

The description is two tight sentences with no filler. It front-loads the core purpose and then adds the important side-effect in the second sentence. Every phrase contributes meaning.

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

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

For a six-parameter record operation with zero schema description coverage, the description covers the core behavior but leaves some parameter semantics (date, note) and potential effects on the loan balance unexplained. The output schema and annotations reduce some burden, but the description alone is not fully complete for all inputs.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the meaning of 'kind' (instalment vs prepayment) and 'account_id' (moved through the bank account, writes cash row), while 'loan_id' and 'amount' are largely inferable from names. However, 'date' and 'note' receive no semantic explanation.

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

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

The description states a specific action ('record') on a clear resource ('loan payment') and indicates two kinds of payments (instalment/prepayment) plus the lending direction. It does not explicitly contrast with siblings like add_loan, update_loan, or log_transaction, but the operation is specific enough to be identifiable.

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

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

The description gives useful guidance for when to include the optional bank account ('which also writes the cash row'), but it does not say when to use this tool versus alternatives such as create_transfer or log_transaction. No exclusions or explicit routing to sibling tools are provided.

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

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

With readOnlyHint=false and idempotentHint=false already signaling a non-idempotent write, the description adds useful behavioral context beyond annotations: it discloses that providing an account also writes the cash row ticket and that the amount is the total before fee. It does not contradict the annotations.

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

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

The description is a single dense sentence with no filler, front-loading the core action and then compactly listing optional inputs and side effects. The parenthetical about the cash row is slightly compressed but still earns its place because it explains an important non-obvious behavior.

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

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

Given the output schema exists and the annotations already communicate the write/non-idempotent nature, the description is largely complete for correct invocation: it names required inputs, clarifies amount semantics, and discloses the conditional cash-row effect. A minor gap is the lack of guidance on edge cases like holding ambiguity or duplicate recording, but that is not essential for a straightforward call.

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

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

Schema coverage is 63%, and the description reinforces some parameter meanings (amount before fee, optional fee, optional account causing a cash row), but much of this repeats the schema's existing descriptions. Parameters like date and note are not elaborated in the description, and kind is only implied by "buy or sell," so the description adds some but not extensive value beyond the schema.

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

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

The opening phrase "Record a buy or sell of a holding" gives a specific verb, resource, and action, making it immediately distinguishable from sibling write tools like record_settlement or record_loan_payment. It also lists the key inputs (quantity, amount, fee, optional account) and the notable side effect of writing a cash row, leaving no ambiguity about what the tool does.

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

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

The description clearly states when to use the tool: to record buy or sell events for a holding. However, it does not explicitly mention when not to use it or point to alternatives such as log_transaction for general cash movements or create_transfer for pure transfers, so an agent must infer the boundary from sibling names and the holding-specific language.

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

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

The description adds useful behavioral context beyond the annotations: it explains the sign convention, notes the optional side-effect of recording the payment against an account, and mentions that the phone picks it up on next sync. Annotations alone do not disclose these details, so this is meaningful extra context.

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

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

Three short sentences, front-loaded with purpose and amount semantics. There is no redundant wording, and every sentence contributes practical information.

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

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

For a six-parameter write operation, the description covers the core scenario, sign convention, optional account effect, and sync behavior. The output schema and structured parameter descriptions fill remaining details. The only notable completeness gap is the lack of sibling routing 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?

Parameter schema coverage is 83%, so most parameter semantics are already documented. The description reinforces the amount-direction meaning and the optional account linkage, but it does not substantially extend what the schema descriptions already provide, warranting the baseline score.

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

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

The description clearly states the operation: recording a repayment between individuals for split bills, and explicitly clarifies that positive amount means 'they paid you' and negative means 'you paid them.' While it is specific, it does not explicitly distinguish itself from sibling tools such as settle_group or record_loan_payment, leaving some differentiation to inference.

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

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

The intended scenario is clear: someone repaid you for a previously split bill. However, there is no explicit when-to-use versus alternatives, no exclusions, and no reference to related tools like settle_group or log_transaction. The guidance is implied but not 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 flag destructiveHint=true, so the description does not need to repeat mutating behavior. It adds that logging creates a transaction on an account, which is useful, but it does not disclose side effects on the planned expense itself (e.g., deletion or marking as resolved). This is a minor gap but not contradictory.

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

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

The description is a single, efficient sentence that front-loads the core purpose and the two possible actions. It is concise and easy to parse, with no wasted words. It could be slightly more formal but is well-structured.

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

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

Given the tool's moderate complexity (5 params, 2 required) and the presence of an output schema, the description covers the essential scenarios (log vs. skip) adequately. It does not describe every edge case (e.g., default date, account handling), but the schema fills those gaps. It is complete enough for correct invocation in most cases.

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

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

Schema description coverage is 60%, and the description adds no parameter-level details. It does not explain the meaning of 'id' (planned expense identifier) or the 'action' enum beyond what the schema lists, nor does it clarify conditional requirements like account_id for log when the plan lacks an account. Since coverage is not high, the description should compensate but fails to.

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

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

The description clearly states the tool's purpose: resolving a planned expense by either logging it as a transaction (with optional real amount/date) or skipping it. It uses a specific verb ('resolve') and resource ('planned expense'), and implicitly distinguishes from siblings like add_planned_expense (creation) and log_transaction (general logging).

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

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

The description provides clear usage context: use it when a planned expense has happened (log it) or won't happen (skip). This is a specific trigger condition, though it does not explicitly name alternatives or exclusions. It is sufficient for an agent to infer when to invoke this tool over generic transaction 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about what kinds of transactions appear in the queue, but it does not disclose ordering, pagination, or how confirmation is expected to happen.

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 sentence with no filler, front-loading the queue's defining trait. Every word earns its place.

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

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

Given the tool has no parameters, an output schema, and read-only annotations, the description covers what an agent needs to understand the queue's purpose and invoke the tool correctly. No critical invocation details are missing.

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

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

The tool has zero parameterschend. No parameter documentation is needed, and there is nothing for the description to add beyond the empty schema. Baseline 4 is appropriate for a parameterless tool.

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

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

The description names a specific resource—transactions awaiting the user's confirmation—and adds inclusion criteria (auto-captured or created via MCP). It is clear enough to distinguish from transaction creation/search tools, though it never states an explicit verb like 'list' or 'retrieve'.

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 about when to call this tool versus alternatives such as search_transactions or unparsed_alerts. The description only defines the queue's contents, so the agent must infer usage from the name and title.

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

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

Annotations already carry the safety profile (readOnlyHint=false, destructiveHint=true), so the burden on the description is lower. The description adds useful behavioral context beyond annotations: validation requires a matching stored alert, force bypasses this, and the rule syncs to the phone for autonomous alert reading. It does not explicitly disclose overwrite behavior, but the destructiveHint annotation partially covers 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?

Three sentences, each earning its place: the first states the core action, the second gives the key validation behavior, and the third explains the sync side-effect. No filler or repetition, and the most identifying 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?

The output schema exists, so the description need not explain return values. The presence of a nested rule object is substantial, but the schema covers its fields. The description adds the essential runtime behavior around alert matching, force, and phone sync. It misses only explicit guidance about overwriting existing rules and how this relates to test_parse_rule, which 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 for the top-level parameters is 0%, so the description must compensate. It adds meaning to the force parameter by explaining it bypasses the stored-alert match requirement. However, it does little to explain the rule object's structure; that burden falls on the nested schema, which does contain rich descriptions. This is adequate but not fully compensating.

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

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

The description opens with a specific verb and object: "Save a parse rule for your account," which clearly identifies the action, resource, and scope. The follow-up about matching a stored alert or passing force=true further distinguishes this from sibling tools like list_parse_rules, test_parse_rule, and delete_parse_rule.

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 an important acceptance condition: the rule must match a stored alert with the right amount, or force=true must be passed. This implies when the tool can be used, but it never explicitly explains when to choose this over test_parse_rule or delete_parse_rule, so the guidance is implied 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 already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a valuable behavioral rule: rows each carry their own currency and must not be summed across currencies. This is exactly the kind of semantic context that goes beyond structured annotations.

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

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

Very short, but the first sentence 'Search transactions' merely restates the title and adds no information. The second sentence is useful and specific. Overall it is efficient but slightly redundant in the opening.

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

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

An output schema exists and annotations cover read-only/idempotent behavior, reducing the burden on the description. However, with 9 optional parameters and no required ones, it's unclear how filters combine, what a bare call returns, how limit applies, or which fields text searches. The currency warning addresses one important behavior but leaves significant 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 33%, covering to, from, and include_raw. Six parameters (text, limit, currency, account_id, category_id, unreviewed_only) have no schema descriptions. The description adds no parameter-level meaning and never mentions these filters. The currency note refers to result rows, not the currency parameter's semantics.

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

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

The description clearly names a verb and resource: 'Search transactions.' Since there is no sibling named 'list_transactions,' the tool's purpose is unambiguous even though the title restates the name. It doesn't explicitly differentiate from sibling tools, but none of them seem to overlap directly.

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, alternative selection, or conditions are provided. The only usage note is a post-aggregation warning about currencies, which is not guidance on when to invoke this tool vs siblings like review_queue, unparsed_alerts, or list_* 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 only state readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the description carries the burden of explaining side effects. It does this well by disclosing that the tool records exactly one adjustment row for the difference and categorizes it as outside spending, which is meaningful behavioral context beyond the annotations.

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

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

Two sentences with no wasted words. The core purpose and mechanism are front-loaded, followed by usage guidance and the alternative tool, making the description quick to scan and act on.

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

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

For a simple 4-parameter tool with an output schema, the description covers purpose, mechanism, trigger condition, and the alternative. It is complete enough for most calls, though it leaves slight ambiguity around when the optional note and as_of parameters should be used.

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%, covering balance and as_of, but note and account_id are undocumented in the schema. The description adds useful context that the balance is 'what the bank shows' and that an adjustment row captures the difference, but it does not fully compensate for the missing parameter semantics of note and account_id.

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-resource pair ('Make an account's balance equal what the bank shows') and explains the mechanism in concrete terms: recording one adjustment row for the difference. It also distinguishes itself from the sibling reconcile_statement, giving an agent enough to tell the tools 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?

The description is explicit about when to use it: after the user reads a balance off their banking app. It also names the alternative condition, 'prefer reconcile_statement when a statement is available', which directly routes the agent to the correct sibling.

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

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

Annotations already convey destructive/write behavior, so the description adds valuable specifics: set or replace, removal via limit 0, one currency per period. It does not go into failure modes or auth, but the main behavioral traits are transparent.

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, key behavior first, no filler. The budget_status pointer is purposeful.

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 core semantics for correct invocation are present, and an output schema exists. It could have stated the monthly default explicitly, but the schema already supplies that, so nothing critical is missing for this simple 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 descriptions cover limit and period; description adds the one-currency rule and reinforces removal via zero. However, category_id and currency remain minimally explained in both description and schema, so the description only partially compensates for the 50% schema coverage.

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

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

States a specific verb ('Set') and resource ('spending limit for a category'), clarifies replace semantics, and distinguishes from budget_status by naming it as the progress reporter. The scope is immediately recognizable among siblings like set_category_rule.

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: use it to set or replace a category budget, pass 0 to remove, and consult budget_status for progress. It lacks explicit when-not-to-use conditions compared with other mutation tools, but the context is sufficient.

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

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

It adds useful behavioral context beyond annotations: the rule persists ('from now on'), syncs ('on the phone too'), and can re-categorise existing transactions. This complements the destructiveHint=true annotation without contradiction, though it does not cover permissions or failure modes.

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

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

The description is a single compact, front-loaded statement. It states the core behavior first, then adds the optional mass-update effect, with no filler or redundant 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?

Given an output schema exists and annotations already signal destructiveness, the description covers the main agent-relevant behavior: persistence, cross-device effect, and optional re-categorisation. It does not explain whether an identical pattern overwrites an existing rule or how category_id is validated, but these are secondary for basic invocation.

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

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

Schema coverage is 67%: pattern and apply_to_existing are well-described. The description reinforces these but adds little new meaning, and category_id remains undocumented in both schema and description—an agent must infer the value type from sibling tools like list_categories.

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

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

The description clearly states the verb and resource: 'Teach the categoriser' so matching merchants get a category from now on. It distinguishes itself from category-creation tools like add_category by framing the action as pattern-to-category rule, 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 description implies when to use it: when you want persistent, pattern-based merchant categorization. However, it does not explicitly say when not to use it or point to alternatives like save_parse_rule or update_category, leaving some inference to the agent.

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

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

Annotations already signal destructiveHint=true, and the description adds the important behavioral detail that the operation 'creates or replaces' the card's terms. This clarifies that existing values may be overwritten. It does not add extraneous behavioral guarantees, but it provides meaningful context beyond the annotations.

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

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

The description is a single well-structured sentence that front-loads the core purpose, lists the relevant terms, and ends with the important upsert behavior. Every phrase earns its place; there is no filler.

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

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

The output schema and annotations reduce some burden, and the description covers the core card-term concepts. Still, apr_percent is left undocumented and the two minimum-due parameters are conflated, so an agent cannot fully infer the semantics of all seven parameters. It is adequate but not complete.

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

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

With schema description coverage at only 43%, the description helps by naming credit_limit, statement_day, due_days_after_statement, and minimum due. However, it omits apr_percent entirely and lumps minimum_due_percent and minimum_due_floor together as 'minimum due', leaving ambiguity. It partially compensates for the schema gap but not fully.

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

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

The description clearly identifies the operation: giving a card account its terms, with the key fields listed (limit, statement day, days until due, minimum due). It also adds the create-or-replace behavior, which helps distinguish it from plain update tools. It does not explicitly name a sibling for contrast, so it stops short of a 5.

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

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

The intended use is implied: use this when configuring a card account's terms. There is no explicit 'use when' or 'use instead of' statement, and no guidance about when update_account or set_account_balance would be more appropriate. The context is clear but only by 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 communicate mutation and destructive potential (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so the description only needs to add context. It adds that this is a manual record with an as-of time, but it does not disclose whether an existing quote is overwritten or what happens to prior values.

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

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

Two sentences with no filler: the action is front-loaded and the second sentence provides necessary context about live-source refresh. Every word earns its place.

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

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

The tool is simple, has an output schema, and annotations cover the destructive/mutation profile, so the description does not need to explain return values or safety. The main gaps are the meanings of holding and the representation of as_of, which an agent needs for correct invocation.

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

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

Schema description coverage is only 33%, so the description must compensate for undocumented parameters. It clarifies as_of as a point in time, but not its expected format, and leaves holding entirely unexplained, making it hard for an agent to know what value to supply.

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 ('Record') and resource ('current price of a holding'), and scopes the action to manual entry from the broker app. The contrast with the app's own live-source refresh clearly differentiates this from related holding tools.

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