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

No annotations are provided, so the description carries the full behavioral burden. 'Marks as approved' implies a state mutation, but there is no mention of reversibility, required permissions, side effects, idempotency, or what happens if the transaction is already approved.

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 zero filler; the action is front-loaded and the prerequisite follows immediately. Every sentence earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description covers the action and the ID-procurement workflow but omits behavioral essentials like reversibility, error conditions, and result confirmation. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the 'last-used' default for budget_id. The description only restates the transaction_id lookup workflow, adding no semantics beyond the schema.

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

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

States a specific verb and resource ('Marks a transaction as approved'), which is clear and distinguishable from read-oriented siblings like list_unapproved_transactions. It stops short of fully articulating scope (e.g., single vs bulk, effect on downstream categorization), so it is clear but not maximally differentiated.

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

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

Explicitly tells the agent to obtain transaction_id via list_unapproved_transactions first, giving a concrete prerequisite and routing to the right sibling for discovery. It does not state when NOT to use this tool or what happens if the transaction is already approved.

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

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

No annotations, so the description carries the full burden. It is transparent about what the digest contains, which is genuinely useful given there is no output schema, but it says nothing about whether the call is read-only, how expensive an aggregate query is, or any auth/rate considerations. 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?

A single tightly constructed sentence with the deliverable front-loaded and the differential clause at the end. No wasted words, and the em-dash list efficiently enumerates the contents.

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

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

No output schema exists, so the description must convey what comes back; it enumerates the return contents adequately. It is fully sufficient for a one-parameter read aggregator, though it stops short of describing formatting or empty-state behavior.

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

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

Single optional budget_id parameter with 100% schema description coverage, including the 'last-used' default semantics. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a concrete deliverable (an at-a-glance budget health digest) and enumerates exactly what it aggregates: Ready to Assign, age of money, overspent categories, uncategorized/unapproved counts. The contrast 'instead of checking each separately' cleanly positions it against the sibling tools like get_ready_to_assign and list_overspent_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?

'Instead of checking each separately' implies when to reach for this composite tool over the granular siblings, giving clear usage context. It does not, however, state when NOT to use it (e.g., when you need the detail of one specific metric), so no explicit exclusions or named alternatives.

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

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

With no annotations, the description carries the burden and does well: it discloses that nothing is applied automatically, that the result is a review list, and that suggestions derive from payee categorization history. It doesn't cover auth requirements or limits, but the core non-mutating behavior is explicit.

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

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

Two sentences, front-loaded with the bulk scope and the safety caveat immediately after; every clause earns its place.

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

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

There is no output schema, so the description correctly notes a review list is returned, and it routes the agent to categorize_transaction. For a single-parameter, non-mutating tool this is essentially complete, though it could say more about what each review entry contains.

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

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

Schema coverage is 100% and budget_id (with its 'last-used' default) is fully documented in the schema, so the description adds no further parameter meaning. Baseline 3 for a single well-documented 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 (suggests), resource (categories), and scope (every uncategorized transaction in a budget at once), and distinguishes itself from the singular sibling suggest_category by emphasizing bulk operation over payee history.

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?

Clearly frames this as a review-only step and names the follow-up tool categorize_transaction to apply an approved suggestion, so the agent knows the workflow. It stops short of explicitly saying when to prefer this over the single-transaction suggest_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?

With no annotations, the description carries the full behavioral burden. For a mutation tool it omits key traits: whether assigning overwrites an existing category, whether the change is reversible, required permissions, and any side effects on budget balances. Only the ID-resolution prerequisite is disclosed.

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

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

Two sentences, no filler, with the action statement front-loaded and the prerequisite follow-up clearly subordinate. Every sentence earns its place.

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

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

Covers the essentials for invoking the tool (action + ID acquisition) and needs no output-schema explanation since none exists. But for an unannotated mutation tool, the missing overwrite/reversibility/permission context leaves meaningful 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%, so all three parameters (including budget_id's 'last-used' default) are already documented in the schema. The description only reiterates that the two required IDs must be looked up, adding no format or semantic detail beyond the schema — the baseline 3.

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

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

Specific verb+resource: 'Assigns a category to a specific transaction.' The verb 'assigns' implicitly separates it from suggest_category/bulk_suggest_categories, but the description never names or contrasts those siblings explicitly, so an agent must infer the distinction.

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

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

It gives real prerequisite guidance — resolve category_id via list_categories and transaction_id via list_uncategorized_transactions first — which is genuinely actionable. However, it offers no when-to-use vs. suggest_category/bulk_suggest_categories guidance and no exclusions or failure conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one real trait: the category group must pre-exist, and the group name is resolved by partial match. However, it says nothing about uniqueness of names, permissions/auth, side effects on the enclosing group, or failure behavior when the group is not found.

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

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

Two sentences, zero filler, and the prerequisite/constraint is front-loaded ahead of the alternative routing. Every clause earns its place.

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

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

For a create tool with no annotations and no output schema, the description covers the critical prerequisite and the group-name resolution path, which is the main thing an agent could get wrong. It stops short of describing duplicate-name handling or error outcomes, but return values need not be explained since no output schema exists.

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

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

Schema description coverage is 100%, so all three parameters (name, budget_id, category_group_name) are already documented in the schema, including the partial-match semantics and the 'last-used' default. The description adds only the discovery path for category_group_name, which is marginal value over the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('Creates a new category') plus a constraint that distinguishes it from the sibling create_category_group: the group must already exist. An agent can differentiate it from create_category_group and list_categories without opening any schema.

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

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

Explicitly names the prerequisite ('Use list_categories first to find the category_group_name') and routes to the alternative when the prerequisite can't be met ('or create one with create_category_group'). This is exactly the when-to-use/when-to-use-something-else guidance the dimension asks for.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose side effects, required permissions, error conditions, or what happens on duplicate names; it only says it creates a group in a budget.

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

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

A single, front-loaded sentence that defines the resource inline and wastes no words. It is appropriately sized for a simple create operation.

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

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

For a simple tool with a fully documented schema and no output schema, the description is largely sufficient; an agent can call it with just a name and an optional budget ID. It could still be improved with basic usage context, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the two parameters (name, budget_id) are already fully documented in the schema. The description adds no parameter-specific detail beyond what the schema provides, meriting the baseline 3.

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

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

States a specific verb ('Creates') and resource ('new category group'), and the parenthetical definition ('a section that categories live under') helps distinguish it from a plain category. However, it does not explicitly name or differentiate itself from sibling tools like create_category.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It simply asserts the action, leaving the agent to infer that this is the tool for creating category groups rather than categories.

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

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

No annotations are provided, so the description carries the full burden. It discloses the heuristic (amounts within 5% of average, at least min_occurrences times), which is valuable behavioral insight. However, it doesn't mention permissions, whether it's read-only, or output format.

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

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

Two sentences, front-loaded with the core purpose, then the heuristic detail. Efficient and no wasted words, though slightly 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?

No output schema exists, so the description should explain return values, but it does not. It covers the input heuristic and usage context adequately but leaves gaps on output and permissions for a detection tool with no annotations.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description references min_occurrences but adds no syntax or format details beyond what the schema provides, so baseline 3 is appropriate.

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

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

States a specific verb ('Flags'), resource ('payees that bill a consistent amount repeatedly'), and scope ('last several months'). Distinguishes itself from siblings like top_payees or spending_trend by naming the recurring/subscription detection intent explicitly.

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

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

The description conveys implied usage ('useful for spotting subscriptions, including ones you may have forgotten about'), which gives some context for when this tool is relevant. However, it doesn't name alternatives or explicitly state when not to use it versus tools like top_payees or search_transactions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the filtering rule (target-less categories are dropped) and implies a read-only operation, but says nothing about authentication/budget-access requirements, pagination, or what happens when no categories have targets.

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 tight sentence that front-loads what is returned and closes with the exclusion rule. No filler, nothing redundant with 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?

There is no output schema, so the description correctly enumerates the return fields (amount, type, due date, progress) and the scoping rule. The only gap is behavioral detail such as failure modes or budget-access requirements for an otherwise simple single-parameter read tool.

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

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

Only one parameter exists and schema coverage is 100%, with the budget_id/'last-used' semantics fully documented in the schema. The description adds no additional parameter meaning, which is the correct baseline when the schema does the work.

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

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

States a specific verb (lists) and resource (categories with a target set) and enumerates the returned data (amount, type, due date, progress). The clause 'Categories without a target are omitted' implicitly distinguishes it from the sibling list_categories, which returns all 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?

Usage is only implied: an agent can infer this is the read path for targets, contrasting with the write path set_category_target. There is no explicit when-to-use or when-not-to-use statement, and no mention of list_categories as the alternative for unfiltered category listing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It partially compensates by disclosing the exact data points returned (income, budgeted, spent, to-assign, age of money), implying a read-only snapshot. However, it says nothing about permissions, side effects, or whether figures are live vs cached.

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

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

A single, front-loaded sentence with no filler; the resource and its return fields are stated immediately with zero 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 two-parameter read tool with no output schema, the description compensates by enumerating the returned metrics, so an agent knows what it will receive. The main remaining gap is the absence of any routing guidance versus the overlapping summary-style 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 schema already documents both 'month' (with 'current' / YYYY-MM-01 semantics) and 'budget_id' ('last-used'). The description adds no parameter syntax or format detail beyond that, so the baseline of 3 applies.

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

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

Specific verb ('Gets') plus a clearly named resource ('financial snapshot for a budget month'), and it enumerates the fields returned (income, total budgeted, total spent, money left to assign, age of money). It is easy to distinguish from list_* siblings, though it does not explicitly differentiate from the overlapping get_ready_to_assign (which covers 'money left to assign').

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

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

There is no when-to-use guidance, no stated prerequisites, and no mention of alternatives such as get_ready_to_assign or spending_by_category. The agent must infer usage purely from the resource name.

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

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

No annotations are provided, so the description carries the full burden. It does useful semantic work by defining what 'Ready to Assign' actually measures, which implies a safe read, but it says nothing about permissions, behavior when no budget exists, whether the figure is a plain number or a formatted/currency object, or error conditions.

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

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

One sentence, front-loaded with the verb and resource, with a clarifying gloss appended after the dash. No filler and nothing extraneous.

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

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

For a single-parameter read with no output schema, the description gets close to sufficient by explaining what value is returned rather than just restating the name. A minor gap remains: it doesn't indicate the return type or whether other budget metrics are needed alongside 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 description coverage is 100% and the single budget_id parameter is fully documented in the schema, including the 'last-used' default, so the description adds nothing beyond it. Baseline 3 applies when the schema does all the heavy lifting.

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

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

States a specific verb (Gets) and a specific resource (the current 'Ready to Assign' amount for a budget), and defines the domain term in-line as 'the money not yet assigned to any category this month.' No sibling is named, but the resource is distinct enough from get_month_summary or get_category_targets that disambiguation is easy.

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

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

Usage is implied by the read-only getter framing: call it when you need the unassigned balance. There is no statement of when-not to use it, no mention of alternatives (e.g., get_month_summary for a broader picture), and no prerequisites. Adequate but leaves routing 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?

No annotations are provided, so the description carries the burden. 'Says hello back' implies a harmless, side-effect-free echo, and the connectivity framing signals it is a diagnostic rather than a data operation. However, it never states whether authentication is required, whether it echoes the supplied name, or what the response contains.

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, front-loaded with the action and immediately followed by its purpose. No filler or redundancy.

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

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

For a trivial one-parameter diagnostic tool with no output schema, the description is nearly sufficient: it conveys purpose and safety. The only minor gap is not hinting at what the reply looks like, but little more is needed for a connectivity check.

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

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

There is a single optional 'name' parameter with 100% schema description coverage ('Your name (optional)'), so the schema already documents it fully. The description adds no additional meaning about the parameter, which is the expected baseline when schema coverage is complete.

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

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

The description names a specific action ('says hello back') and states its exact role: confirming the YNAB MCP server is connected and working. That role clearly distinguishes it from every sibling, which are all budget/transaction/category operations.

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

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

It gives a clear condition for use — verifying server connectivity/health — which is the primary reason an agent would call it. It does not explicitly say when not to use it or name alternatives, but for a connectivity probe none realistically exist among the siblings.

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

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

With no annotations, the description carries the full burden. It usefully discloses the current-month default and that intra-account transfers are excluded, which is genuine behavioral context. However, it does not state the sort order (implied 'biggest'), pagination, or return shape, leaving meaningful gaps.

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

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

Two tight sentences with the core action front-loaded, followed by the scope default and the transfer exclusion. Every clause carries information and nothing is wasted.

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

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

For a read-only list tool with full schema coverage and no output schema, the description covers verb, scope, default range, and an important filtering rule (excludes internal transfers). Absent is any explicit description of ordering or result fields, but the essentials for correct invocation are present.

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

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

Schema coverage is 100%, so the schema already documents all four parameters with defaults. The description's 'defaults to the current month so far' is consistent with the schema's since_date/until_date defaults but adds no new syntax or format detail. Baseline 3 applies.

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

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

States a specific verb (Lists) and resource (biggest purchases/outflows) with a clear scope (date range). It is reasonably distinguishable from siblings like top_payees and spending_by_category, though it never names those alternatives to sharpen the contrast.

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 quick gut-check on where money actually went' implies an exploratory use case but gives no explicit when-to-use vs when-not guidance and does not point to any alternative tool. Usage 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?

No annotations exist, so the description carries the full behavioral burden. It does disclose one useful trait — only *open* accounts are returned, with current balances — but says nothing about permissions, pagination, ordering, or whether a default budget is implied.

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

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

A single front-loaded sentence with zero filler; the parenthetical examples add clarity without bloat.

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

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

For a simple read-only list tool with no annotations and no output schema, the description adequately conveys what is returned ('with their current balances'). It stops short of explaining the budget_id default behavior or how it differs from the very similar sibling tool.

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

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

Schema description coverage is 100%, so the single budget_id parameter and its 'last-used' default are already documented in the schema. The description adds no extra meaning about the budget scoping, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Lists the open accounts in a budget') and enumerates account types, so the agent knows exactly what is returned. It does not, however, distinguish itself from the sibling 'list_all_account_balances', which sounds like an overlapping resource.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative is named. With a sibling ('list_all_account_balances') that appears to cover a similar purpose, the absence of routing guidance is a real gap.

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

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

No annotations are provided, so the description carries the full burden. It mentions that results are grouped by budget, which is useful, but it doesn't disclose whether this is a read-only operation, whether it requires authentication, how large the result set might be, or what the response format looks like. For a zero-annotation tool, this is a significant gap.

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

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

Two sentences, both front-loaded with the core action and scope, and the second sentence adds practical context without waste. Every sentence earns its place.

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

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

For a parameterless read tool with no annotations and no output schema, the description provides the essential purpose and use case but omits important behavioral details like read-only nature, authentication requirements, and return shape. It is adequate but not fully complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly implies no filtering or input is needed, consistent with the empty schema.

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

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

States a specific verb (Lists) and resource (account balances) with clear scope (across every budget, grouped by budget). This is clearly distinguishable from siblings like list_budgets or get_month_summary, which serve different aggregation 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?

The description gives clear context: useful for a full net-worth view without checking each budget individually. This implies when to use it (when you need an aggregate net-worth snapshot). However, it doesn't explicitly name an alternative sibling tool or state 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?

With no annotations, the description carries the full behavioral burden and does disclose the return shape (IDs and names), which is genuinely useful. However it omits authentication requirements and whether the result is paginated or scoped, leaving notable gaps for a zero-annotation 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 front-loaded sentence with no filler; every word (resource, account scoping, returned fields) 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 trivial no-param list tool with no output schema, the description conveys the essential return contents, which is sufficient to call it correctly. Only minor details like pagination or auth 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?

The tool takes no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool applies. No misleading parameter claims are present.

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

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

States a specific verb ('Lists') and resource ('YNAB budgets') and adds the return contents (IDs and names). The resource is distinct from siblings like list_accounts and list_categories, though it does not explicitly name an alternative to route against.

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

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

There is no when-to-use guidance, no mention of the sibling tools that also list resources, and no stated prerequisites such as authentication or budget-scoping. Usage is only inferable from the name.

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

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

No annotations are provided, so the description carries the full burden. It discloses the payload shape (IDs, names, remaining balances), which is useful, but says nothing about whether hidden/deleted categories are included, ordering, pagination, or budget permissions. For a low-risk read operation this is acceptable 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 short sentences, zero filler, and the core purpose is front-loaded before the cross-tool hint. Every sentence earns its place.

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

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

There is no output schema, but the description compensates by naming the fields returned, and the single optional parameter is fully covered by the schema. Only minor gaps remain (ordering, filtering, inclusion of hidden categories).

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%: budget_id is fully documented in the schema, including the 'last-used' default. The description only echoes 'in a budget' and adds no syntax or semantics beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Lists the category groups and categories in a budget') and even enumerates the returned fields (IDs, names, remaining balances). It is clear what the tool does, but it never contrasts itself with adjacent siblings like get_category_targets, list_overspent_categories, or spending_by_category, so sibling differentiation is left 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 second sentence ('Use a category's id with categorize_transaction') is a downstream handoff hint, implying the tool is used when you need category IDs. There is no explicit when-to-use versus alternatives and no exclusion conditions, so usage is only implied.

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

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

With no annotations, the description carries the full disclosure burden, and it does add one valuable trait: it explicitly states the tool is informational and moves no money, which reassures the agent this is non-mutating. It does not cover pagination, ordering, or what the returned records contain, which are meaningful gaps for a tool shipped without annotations or an output schema.

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

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

Two short sentences, zero waste, and the definition of 'overspent' is front-loaded right after the core action. The em-dash clause and the informational disclaimer both earn their place.

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

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

For a simple, single-parameter, read-only list tool, the description conveys what is listed, the scoping window, and the non-mutating nature. Return-shape details are not strictly required since no output schema exists and the result is a straightforward category list, though a note on ordering or fields would close the last gap.

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

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

Schema description coverage is 100% and the single budget_id parameter is fully documented in the schema, including the 'last-used' default. The description adds no further meaning about this parameter, so the baseline 3 applies.

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

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

States a specific verb ('Lists') and resource ('categories') and even defines the filter criterion — categories with a negative balance this month. An agent immediately knows this is a pre-filtered view, distinguishable from the broader list_categories. It stops short of naming which sibling to prefer when full category data is needed, so not quite 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?

'Informational only; does not move any money' hints at a read/diagnostic use case, implying this is a reporting tool rather than an action. But there is no explicit when-to-use vs alternatives such as list_categories or spending_by_category, and no stated preconditions. Usage is only implied.

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

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

No annotations are provided, so the description carries the full burden. It correctly characterizes the operation as a read/list with a clear domain concept (unapproved vs. approved), but does not mention permissions, pagination, return format, or whether approval status is mutable via other tools. For a read-only list tool with no annotations and no output schema, this is adequate but has gaps.

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

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

Two concise sentences that are front-loaded: the core purpose first, then a crucial semantic clarification about the separation from categorization. No wasted words.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no nested objects), the description is nearly complete for an agent to invoke it correctly. The only minor gap is the absence of any note on return volume or pagination, but that is beyond the typical scope for a list tool without an output schema.

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

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

Schema coverage is 100%, and the single parameter budget_id is fully documented in the schema with a default. The description adds no parameter detail beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description states a specific verb (lists) and resource (unapproved transactions), and adds parenthetical clarification of what those transactions typically are (bank-imported awaiting review). It is clearly distinguishable from sibling list_uncategorized_transactions and approve_transaction.

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

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

The description implicitly tells the agent when to use it (to find transactions that haven't been approved), and the second sentence distinguishes it from categorization workflows. However, it doesn't explicitly name an alternative tool or state 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?

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only list operation, but says nothing about ordering, pagination, result limits, or whether the default 'last-used' budget applies. For a simple read tool 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?

A single tight sentence that front-loads the core operation and adds a brief purpose clause. No wasted words, though it is on the terse side given no output schema exists.

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 list tool it is close to sufficient, but with no output schema and no annotation coverage, details like returned fields, ordering, or pagination behavior are left entirely unspecified.

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 budget_id parameter is fully documented in the schema, including the 'last-used' default. The description adds no parameter meaning beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb (Lists) and resource (transactions) with a clear scope qualifier (don't yet have a category assigned). This distinguishes it from general listing tools, though it does not explicitly name siblings like list_unapproved_transactions or search_transactions.

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

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

The phrase 'so they can be reviewed and categorized' implies the workflow context (pre-categorization review), giving some usage guidance. However, it never says when to choose this over search_transactions or how it relates to categorize_transaction/suggest_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?

With no annotations, the description carries the full burden and does disclose the core mechanic: source assigned amount decreases and destination increases by the same amount, scoped to a single month. However, it omits failure behavior (what happens if the source category has insufficient assigned funds), permission requirements, and whether the move is reversible or recorded elsewhere.

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

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

Three tight sentences: purpose and scope first, mechanism second, prerequisite last. No filler and nothing redundant with the schema.

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

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

A mutation tool with no annotations and no output schema needs the description to cover behavior fully, and it covers the mechanics and the ID-lookup prerequisite adequately. It leaves out error conditions and the response shape, which the agent would need for a write operation of this kind.

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

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

Schema description coverage is 100%, so all five parameters including defaults are already documented in the schema, establishing a baseline of 3. The description's $50 Child Support→Haircuts example slightly clarifies directionality of from/to, but adds no syntax or format detail beyond the schema.

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

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

States a specific verb (moves) and resource (budgeted money between categories) with the scope constraint (within the same month) and a concrete example. An agent can distinguish this from siblings like set_category_target or create_category without opening any schema.

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

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

Gives the precondition for invocation (look up category_id values with list_categories first) and a usage scenario (covering a specific expense), which clearly orients the agent. It does not say when NOT to use this tool, e.g. across months or between budgets, so it stops short of the top 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?

With no annotations, the description carries the full burden. It does disclose meaningful behavioral scope — 'every open account' excludes closed accounts, and it reports the shape of the result. However, it never states that the operation is read-only, nor how multi-currency or missing-balance accounts are handled, so key traits remain implicit.

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

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

A single, front-loaded sentence that leads with the verb and scope and terminates with the output shape. Nothing is redundant and nothing is padded.

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

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

For a zero-parameter, read-style aggregate with no output schema, the description adequately covers what it computes and what it returns. It could go further by confirming read-only behavior and noting currency/closed-account handling, but the essentials are present.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline of 4 applies. The description correctly implies no inputs are needed for the snapshot.

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 ('Totals') and resource ('current balance across every open account in every budget') and names the exact output ('a single net worth figure, plus a per-budget breakdown'). This distinguishes it from the sibling list_all_account_balances, which enumerates balances rather than aggregating them.

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

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

The aggregation scope implicitly tells the agent when this tool is appropriate (need a single net-worth number rather than per-account detail), but there is no explicit when-to-use statement and no mention of alternatives like list_all_account_balances or get_month_summary.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers only the AND-combination semantics. It says nothing about the result cap (limit defaults to 50), ordering (most recent first), whether results are paginated, or any permission/auth requirements — all of which matter for a search tool.

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

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

Two short sentences, no redundancy, and the core purpose is front-loaded before the filter semantics. Every clause earns its place.

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

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

For a 7-parameter search tool with no annotations and no output schema, the description covers the input semantics but omits the return shape: how many transactions come back, their ordering, and whether the limit is a hard cap. It is minimally adequate but not complete.

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

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

Schema description coverage is 100%, so every parameter (limit, budget_id, payee_name, since_date, until_date, account_name, category_name) is already documented in the schema. The description adds only the meta-claim that filters are optional and combinable, so the baseline 3 applies.

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

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

States a specific verb (searches) and resource (transactions) scoped to a budget, and enumerates the filter dimensions (payee, category, account, date range), which is far more informative than the bare name. It does not, however, distinguish itself from siblings like list_uncategorized_transactions or list_unapproved_transactions, which are also transaction listings with implicit filters.

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?

"All filters are optional and combine together" tells the agent that no parameters are required and that filters intersect, which is a genuine usage hint. But there is no statement of when to prefer this tool over the sibling listers (list_uncategorized_transactions, list_unapproved_transactions, spending_by_category), leaving the routing decision 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose that this is a mutating operation with a destructive branch (clearing an existing target) and states the mutual-exclusivity constraint, which is useful. But it omits permissions, reversibility, idempotency, and what the caller gets back, and much of what it states (clear_target semantics, exclusivity) is duplicated from the schema.

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

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

Three short sentences, zero filler, and the core action is front-loaded before the conditional rules. Every sentence earns its place and nothing needs trimming.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description covers the main invocation modes but leaves gaps: it does not describe the return value, error conditions when both modes are supplied, or side effects on related budgeting views. 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?

Schema description coverage is 100%, so every parameter is already documented in the schema, including the exclusivity rules and the clear_target meaning. The description adds no syntax, units, or format detail beyond what the schema provides (e.g., no example date format, no note on budget_id default behavior). Baseline 3 applies when the schema does the heavy lifting.

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

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

The description opens with a specific verb triad and resource: "Sets, updates, or clears a target (goal) on a category." That is unambiguous and implicitly separates it from the read-only sibling get_category_targets. It stops short of naming that sibling or stating a scope boundary, so it is clear but not fully differentiated.

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

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

The description gives real conditional guidance for the two target modes ("Provide either goal_target_date ... or goal_frequency ..., not both") and for removal ("Pass clear_target: true"). However, it never says when to use this tool versus alternatives such as get_category_targets or how to proceed if a target already exists, so usage is implied rather than fully framed.

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

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

No annotations are provided, so the description carries the full burden. It discloses two genuinely useful behavioral facts: the default date window and that internal transfers between one's own accounts are excluded from totals. It does not state read-only nature explicitly, permission requirements, or the shape of the returned per-category figures.

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 operation is front-loaded and the exclusion clause follows. 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?

For a read aggregation tool with fully documented parameters and no output schema, the description covers the operation, defaults, and one important filtering caveat. The main remaining gap is the shape of the result (per-category totals keyed by category), which the schema does not supply.

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

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

Schema description coverage is 100%, so all three parameters (budget_id, since_date, until_date) are already documented, making 3 the baseline. The description restates the date-range default but adds nothing about date format or the budget_id 'last-used' sentinel, and its 'current month so far' phrasing sits slightly awkwardly against the schema's 'no upper bound' default for until_date.

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

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

States a specific verb and resource ('Reports total spending per category') plus the scoping dimension (date range), so an agent can distinguish it from listing tools like list_categories or summary tools like get_month_summary. It does not explicitly name which sibling to prefer, but the purpose itself 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 implies its usage context by noting the default range ('defaults to the current month so far'), which signals the common call pattern. However, it never says when to choose this over alternatives such as get_month_summary or list_overspent_categories, so the guidance stays implicit.

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

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

No annotations are provided, so the description carries the behavioral burden. It is evidently a read-only trend query and the phrase 'month by month' hints at the returned series shape, but there is no explicit statement that it is non-mutating, nor any note on permissions, defaults, or ordering of results.

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

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

Two sentences, front-loaded with the core behavior and followed by a brief purpose statement. No wasted clauses, though the em-dash aside adds mild length without new information.

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

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

With no output schema, the description adequately conveys that the result is a month-by-month trend series rather than a single total, which is the key expectation an agent needs. It is a simple read tool with fully documented params, so the remaining gaps (exact return fields) are minor.

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

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

Schema description coverage is 100%, so the schema already documents months, budget_id, and category_name fully. The description only echoes the overall-vs-category distinction, adding no format or matching detail beyond what the schema already provides; baseline 3 applies.

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

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

States a specific verb and resource: 'shows how spending has changed month by month over a recent window,' with scope options (overall or one category). It is clearly distinguishable from the by-category breakdown or month-summary siblings, though it does not name any sibling explicitly.

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

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

The second sentence gives implied usage ('spotting whether spending in an area is creeping up or down over time'), which tells the agent the analytic intent. However, there is no when-not guidance and no routing to alternatives like spending_by_category or get_month_summary for a single-period breakdown.

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

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

With no annotations, the description carries the full burden and does disclose two important traits: irreversibility ('cannot be undone via this tool') and a precondition (fails on already-split transactions). It does not mention permission requirements or side effects on budget/category balances, so it is strong but not exhaustive.

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

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

Front-loaded verb, followed by a compact illustrative example and then the key constraints. Every sentence earns its place; the example is genuinely clarifying rather than filler.

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

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

For a mutation tool with no annotations and no output schema, the description covers the critical safety and precondition facts an agent needs. It stops short of describing what happens to the original transaction record or any confirmation/return behavior, but the essentials are present.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: the minimum of two splits and the requirement that portions sum to the transaction total, reinforcing the array-level constraint beyond per-field docs. It adds little on budget_id or transaction_id, which the schema already documents.

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 ('Splits a single transaction across multiple categories') and clarifies the mechanics with a concrete example ($75 haircut split into $50/$25). An agent can distinguish this from siblings like categorize_transaction without opening a schema.

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

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

Gives clear applicability constraints (at least 2 splits, amounts must sum to the total, does not work on already-split transactions), which tells the agent when the tool is valid. It does not, however, explicitly name the alternative (e.g. categorize_transaction) for the single-category case, leaving that routing to inference.

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

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

With no annotations, the description carries full burden. 'Suggests' implies a read-only operation and the description explains the suggestion logic (past payee categorization, amount disambiguation), but it never explicitly confirms no side effects and does not describe the return format or confidence.

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

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

Two sentences, front-loaded with the core purpose and followed by a specific, useful edge case. No filler or repetition; every sentence earns its place.

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

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

For a simple suggestion tool with a fully described schema but no output schema or annotations, the description is adequate but incomplete. It omits the return format (e.g., single category vs. ranked list) and does not explicitly confirm read-only behavior, which an agent would need to invoke it confidently.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining how payee_name and amount are used: suggestions come from past payee categorization and amount helps disambiguate multiple charges. Budget_id is left to the schema, but the extra semantic context lifts this above baseline.

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

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

States a clear verb (suggests) and resource (category for a transaction), and explains the basis (past payee categorization). However, it does not explicitly distinguish itself from the sibling bulk_suggest_categories, leaving the single-vs-bulk scope to be inferred from the singular 'a transaction'.

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

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

Gives a useful scenario ('especially useful when one payee covers multiple different charges... told apart by amount') but does not state when to prefer this tool over alternatives like categorize_transaction or bulk_suggest_categories. It provides a condition for value, not a complete when-to-use rule.

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

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

With no annotations, the description carries the full burden and does add real behavioral context: it discloses that inter-account transfers are excluded and that the window defaults to the current month so far. It does not mention ordering guarantees, rounding, or what happens when a payee has zero spend, but the key filtering rule is stated.

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

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

Two sentences, zero filler, with the core function front-loaded and the exclusion rule appended as a scoping caveat. Nothing here is redundant.

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

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

For a read-only aggregation with full parameter documentation and no output schema, the description conveys the grouping key, sort intent and default window, which is enough to call it correctly and interpret the result shape. Minor gaps (e.g., whether results are truncated by limit only) remain but are not blocking.

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 limit, budget_id, since_date and until_date are all documented in the schema itself. The description only echoes the date-default behavior already stated in the schema, adding no new syntax or format detail beyond it — the baseline 3 applies.

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

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

States a specific verb and resource — 'reports total spending grouped by payee' — plus the ranking intent ('who you spend the most money with'). It implicitly distinguishes itself from spending_by_category by the grouping key, but never names or contrasts the sibling explicitly.

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

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

Usage is implied by the grouping ('grouped by payee') and the default window, so an agent can infer when it fits. However, there is no explicit when-to-use/when-not guidance and no alternative named among siblings like spending_by_category or spending_trend.

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