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

Annotations already declare readOnlyHint=true, so the read-only behavior is covered. The description adds context that it returns a running balance at transaction dates, but does not clarify what 'key transaction dates' means or any aggregation or pagination behavior. 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, well-structured sentence with no filler. The verb and resource are front-loaded, and the description is immediately scannable.

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

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

For a read-only tool with one required parameter and no nested objects, the description plus schema and annotations is largely sufficient for selecting and invoking the tool. The main gap is the vague 'key transaction dates' and lack of explicit output shape, but no output schema exists and the tool is simple.

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%: all three parameters are described in the input schema. The description adds no parameter-level meaning beyond what the schema already provides, 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?

Description uses a specific verb ('Track') and resource ('an account's balance changes over time'), and clarifies the output concept ('running balance at key transaction dates'). It does not explicitly name sibling tools, so differentiation from get_transactions or get_category_balance is implicit rather than direct.

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

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

The description implies the tool is for balance-over-time queries, but it gives no explicit when-to-use guidance or alternatives among the many sibling tools. There is no exclusionary routing like 'use get_transactions for raw transaction lists'.

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

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

The annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds the behavioral trait of highlighting over/under-budget categories, which is useful context beyond the annotation. However, it does not disclose specifics like whether the result is a summary or detailed breakdown, or if default behavior (current month) is implied. This adds some value but not extensive 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 two sentences, front-loading the core purpose and immediately adding the distinguishing highlight outcome. Every word earns its place; there is no fluff or repetition.

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

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

Given the tool's relative simplicity, two optional parameters, and the read-only annotation, the description is fairly complete. It explains what the tool does and the key output (highlights categories). The absence of an output schema is mitigated by the clear statement of what is returned (comparison and highlights). The only minor gap is not detailing the return format (e.g., table vs list), but this is not critical.

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

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

The schema description coverage is 100%, meaning both parameters ('group' and 'month') are already documented with meaning. The description implies that 'month' is a filter and 'group' may be a category filter, but it doesn't add syntax or default behavior beyond the schema's 'Defaults to current month'. With full schema coverage, the baseline is 3, and the description provides marginal additional 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 clearly states a specific verb ('Compare') and resource ('budgeted amounts versus actual spending'), with a defined scope ('for each category in a given month') and a distinguishing outcome ('highlights over-budget and under-budget categories'). This is distinct from sibling tools like 'get_budget_month' or 'spending_by_category', so an agent can easily tell them 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 indicates when to use this tool (to compare budget vs actual for a month) and the outcome it provides. However, it does not explicitly state when not to use it or mention alternatives; although the sibling list includes related tools like 'get_budget_summary' or 'spending_by_category', no exclusions are given. This is clear context but lacks alternative routing.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds a small behavioral cue ('Identifies increasing/decreasing patterns') but does not explain how trends are computed, what aggregation is used, or what the output looks like. It adds some value but remains 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?

Two short sentences with no filler. The primary action is front-loaded, and the second sentence adds analytical intent. 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?

This is a simple read-only tool with two optional parameters, and the schema covers both. The description suffices for basic invocation. However, with no output schema, it could have briefly described the result shape or what 'trends' means in the response; its absence is a minor gap rather than a critical one.

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

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

Schema description coverage is 100% – both 'months' and 'category' have descriptions, including the fallback behavior of 'category' when omitted. The description itself adds no parameter-level information beyond the schema, so the baseline of 3 applies.

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

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

The description states a clear verb and resource: 'Show spending trends for a category across multiple months.' It distinguishes this from simple spending breakdowns like spending_by_category by emphasizing 'trends' and 'patterns.' However, it does not explicitly name any sibling alternative, 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?

Usage is implied rather than stated: an agent can infer the tool is for analyzing category spending patterns over time. There is no explicit when-to-use guidance, exclusions, or comparison with alternatives like spending_by_category, spending_projection, or monthly_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?

The readOnlyHint=false annotation already signals mutation, and the description adds meaningful behavior beyond that: it explains that a new account is created and that the response returns the new account ID. This is useful because there is no output schema. It does not over-explain obvious or schema-covered details.

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

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

The description is two concise sentences with no filler. The core action is front-loaded, and the return-value note earns its place by explaining the practical follow-up use case.

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

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

For a simple creation tool with three well-documented parameters and no output schema, this description is complete. It states what is created, notes the account type options, and describes the return value. No important calling context is missing.

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

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

Schema description coverage is 100%, so the schema already thoroughly documents name, offBudget, and initialBalance. The tool description does not repeat parameter details, which is appropriate; it does not need to compensate for any schema gaps.

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 a new budget account') and clarifies the on-budget/off-budget distinction. This clearly separates it from sibling tools like create_category_group or create_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 gives clear context: use this when creating a budget account, and it even notes that the returned account ID can immediately be used by transactions. It does not explicitly mention alternatives, but the intended use case is obvious and not misleading.

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

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

Annotations declare readOnlyHint=false indicating a write operation. The description 'Create a new budget category' aligns with this but adds no additional behavioral context—no mention of side effects, permission requirements, or interactions with related data. Since the bar is lower with annotations present, the description still fails to provide any extra transparency.

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 clean sentence with no redundancy. It front-loads the action and scope, making it easy to scan. 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 simple create operation with two parameters, the description is mostly complete. It lacks an explicit note about prerequisites (e.g., group existence), but given the straightforward nature and the existing schema, it covers the core need. A few extra words about the group being pre-existing 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?

Both parameters are fully described in the schema (100% coverage). The description does not add further explanation about parameter semantics, so it does not go beyond the baseline of 3. The schema already explains name and group sufficiently.

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 verb 'create' with a specific resource 'new budget category within a category group'. This precisely distinguishes it from sibling tools like create_category_group (which creates the group itself) and update_category (which modifies existing categories). No ambiguity remains 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?

No usage guidance is provided. The description does not state when to use this tool versus alternatives, nor does it mention prerequisites (e.g., the category group must already exist). An agent has to infer that this is for adding a category 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?

The annotations already declare readOnlyHint=false, indicating this is a write operation, so the description doesn't need to state that. However, the description adds no further behavioral context, such as whether the group starts empty, requires permissions, or has side effects. It provides only the minimal verb and object, so it doesn't add value beyond the annotation.

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

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

The description is a single, concise sentence that front-loads the primary action and purpose. It contains no filler or redundant information, making it easy to parse quickly.

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 create operation with one parameter and no output schema, the description provides sufficient information for an agent to understand the tool's purpose. It could optionally mention that the new group starts empty or that categories can be added later, but this is not essential given the tool's simplicity. The description is adequate.

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 fully documents the single parameter 'name' with a description 'Name for the new category group' (100% coverage). The tool description repeats the purpose but adds no additional semantics, constraints, or examples. Given the high schema coverage, a baseline of 3 is appropriate; the description doesn't enhance parameter understanding.

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 'Create' and the resource 'category group', and explicitly mentions its purpose of organizing budget categories. This distinguishes it from siblings like create_category (which creates a category within a group) and update_category_group/delete_category_group. The intent 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 usage (when you need a new category group) but does not explicitly state when to use this vs. alternatives, nor does it mention any prerequisites or exclusions. It relies on the name and context to infer the appropriate use case. While it's straightforward, there's no direct 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 communicate that this is a write operation (readOnlyHint false). The description adds no further behavioral context—no mention of side effects, required permissions, duplicate handling, or response behavior—beyond the verb 'Create.'

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, direct sentence with no filler. It is front-loaded and communicates the essential purpose immediately without unnecessary detail.

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

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

For a low-complexity tool with one parameter and no output schema, the description is sufficient to understand the operation. However, it omits any usage context or behavioral notes that could help an agent decide when and how to invoke it safely, keeping it just shy of a perfect score.

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

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

The input schema already documents the single 'name' parameter with 100% coverage, so the baseline is 3. The description does not add any extra meaning about the parameter, but it does not need to given the schema's completeness.

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 a new payee'), which clearly identifies the operation and distinguishes it from sibling tools like update_payee, delete_payee, and get_payees. No ambiguity remains 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 provides no guidance on when to use this tool versus alternatives, such as when to create a payee versus reusing an existing one via update_payee. It is self-evident for a simple create operation, but no explicit context or exclusions are given.

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

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

The description is consistent with the readOnlyHint annotation (false implies mutation), and 'Create' clearly indicates a write operation. However, it doesn't add behavioral details beyond that, such as whether rules apply retroactively, the persistence model, or potential side effects. With annotations covering the basic write nature, this is adequate but minimal.

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 captures the essential purpose without redundancy. No filler or unnecessary 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?

The description gives a high-level overview but does not explain how the condition and action parameters interact, what the stage parameter does beyond the schema's brief note, or the expected behavior on success. For a rule creation tool with 6 parameters, an agent might need more context to assemble a correct call, though the schema does cover individual fields.

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 all parameters already have descriptions. The tool description does not add any meaning beyond the schema, such as relationships between condition_field and action_field or the semantics of the stage parameter. It meets the baseline for high schema coverage but provides no extra value.

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

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

The description clearly states the action ('Create a transaction rule') and the resource, and explains the core behavior: matching a condition triggers an action automatically. It doesn't explicitly distinguish from siblings like get_rules or delete_rule, but the verb and resource make it obvious.

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 provided on when to use this tool versus alternatives such as get_rules or delete_rule, nor any context about prerequisites or typical scenarios. The description only states what it does, not when to choose 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 convey that this is a mutating operation (readOnlyHint: false). The description adds a meaningful behavioral invariant: 'The split amounts must sum to the total.' It also frames the transaction as 'bank-facing total,' which adds context. However, it does not disclose failure behavior, reversibility, or side effects beyond the sum constraint, and much of the constraint detail is already in the schema.

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

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

The description is a single, focused sentence that leads with the action and resource, then immediately states the key constraint. There is no redundant phrasing or filler. Every part 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 mutating tool with complete schema documentation and readOnlyHint annotations, the description is nearly sufficient. It explains the split concept and sum requirement, which are the main non-obvious aspects. It lacks explicit guidance on how this tool relates to create_transaction, but the schema and annotations cover most operational context, making this a minor gap.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the input schema. The description adds little parameter-level meaning beyond the schema, only reinforcing the sum relationship. With complete schema coverage, the baseline of 3 is appropriate; the description does not compensate for any gaps because there are none.

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 provides a specific verb ('Add') and resource ('split transaction'), and clarifies the core concept with 'one bank-facing total spread across multiple categories.' It is clearly distinguishable from generic transaction tools, though it does not explicitly name sibling alternatives like create_transaction. The description is clear but relies on the tool name for 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 (when a single bank-facing total needs to be allocated across multiple categories), but it does not explicitly contrast with alternatives such as create_transaction or state when not to use it. No exclusions or alternative routing are provided, so an agent must infer the appropriate choice from context 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 annotation readOnlyHint=false already indicates a write operation, so the description does not need to restate that. The description adds the sign convention (negative for expenses, positive for income), which is a useful behavioral rule for input values. However, it does not disclose what happens after creation (e.g., balance updates, validation, or return value), which would be valuable context.

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

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

The description is a single, focused sentence that leads with the core purpose and includes the critical sign convention. There is no wasted wording, and the structure is optimal for a 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?

With a comprehensive schema covering all parameters and defaults, the description is adequate for a simple create operation. It does not explain return values, but no output schema exists. It might be improved by noting prerequisites (e.g., account must exist) or that amounts are in human units, but the schema already includes these details. Overall, the description plus schema is sufficient for an agent to call it correctly.

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

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

Schema coverage is 100%, meaning all parameters are described in the schema. The description adds the sign convention, which is also present in the amount parameter description, so it reinforces but does not substantially extend beyond the schema. The phrase 'to an account' reiterates the account parameter's role, but adds little beyond the schema. Baseline 3 applies given full schema coverage.

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

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

The description clearly states the verb 'Add' and the resource 'transaction', specifying that it adds to an account. It also includes the sign convention for amounts, which adds specificity. However, it does not explicitly distinguish from siblings like create_split_transaction or create_transfer, though the name and verb make it reasonably distinct.

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 create_split_transaction for split entries or create_transfer for transfers. The only usage-related note is the sign convention for amounts, which is about input formatting, not tool selection. This leaves the agent to infer when this tool is appropriate.

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

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

The description only restates the mutating nature of the operation that readOnlyHint=false already implies. It does not disclose side effects such as whether both account balances are affected, whether the transfer is reversible, or whether any additional transaction records are created.

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, active-voice sentence with no filler, repeated terms, or unnecessary background. The action and resource are front-loaded and immediately clear.

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 mutating financial operation with no output schema and no usage guidance, the description is too sparse. The schema covers parameter names, but the description does not explain how this tool differs from create_transaction, what happens when the transfer is created, or what the agent should expect as a result.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the input schema. The description adds only the general 'between two accounts' framing and no extra detail about constraints or behavior beyond what the schema provides.

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 both the action ('create') and the resource ('a transfer'), and clarifies the scope as 'between two accounts.' It is not a tautology, but it does not explicitly contrast with adjacent sibling tools like create_transaction or create_split_transaction, 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 description provides no guidance on when to use this tool versus alternatives such as create_transaction or create_split_transaction. It also omits prerequisites like whether the referenced accounts must already exist.

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 (destructiveHint: true, readOnlyHint: false), the description adds critical behavioral detail: it previews on first call, requires confirm: true and confirm_name, and is irreversible. This significantly clarifies the tool's runtime behavior, which the annotations alone 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?

Three sentences with no wasted words: the main action, the destructive warning, and the alternative usage. The most important information (deletion and preview behavior) is front-loaded, and every sentence earns its place.

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

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

For a destructive tool with no output schema, the description fully covers the invocation flow: preview, confirmation, and the alternative of closing. It explains the safeguard mechanism and the irreversible nature. An agent has all necessary information to call it correctly without additional context.

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

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

Schema coverage is 100%, and each parameter already has a clear description (account, confirm, confirm_name). The description reiterates the confirmation requirements but does not add new semantic meaning beyond the schema. Since the schema fully documents the parameters, the description's contribution is minimal, consistent with the baseline of 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?

The description states a specific verb and resource: 'Delete an account and its entire transaction history.' It also conveys the destructive scope and implies the operation is distinct from closing an account, which is mentioned as a preferred alternative. While it doesn't name a sibling tool explicitly, the action is unambiguous and distinct from other delete tools like delete_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?

It explicitly provides usage guidance: 'Prefer closing an account when you just want to retire it' gives a clear when-not-to-use condition and an alternative behavior. The description also explains the two-step confirmation process, setting expectations for how to invoke the tool safely.

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 the annotations already flag destructiveHint=true, the description adds rich operational detail: irreversible deletion, preview-first flow, exact-name confirmation, destruction of budget and rollover history, and the transfer_to safety valve. This goes well beyond the annotation's simple flag.

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 text is three concise sentences: the first states the core action, the second details the confirmation requirement and preview-versus-delete behavior, and the third states side effects and the transfer option. Every sentence delivers essential information with 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?

For a high-stakes destructive tool with no output schema, the description fully covers the invocation flow, required confirmation inputs, irreversible side effects, and optional transfer behavior. It leaves no ambiguity about how to call it safely and what to pass.

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 covers 100% of parameters with individual descriptions, but the tool description adds important relationships beyond the schema, explaining that confirm and confirm_name gate the actual deletion and that transfer_to preserves transactions. This adds behavioral meaning not obvious from isolated parameter 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 opens with 'Delete a budget category,' clearly identifying the action, resource, and scope. This distinguishes it from sibling tools like delete_category_group, update_category, and delete_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 provides clear context for use: it previews first, then requires confirm and confirm_name, and offers transfer_to as an option. It indirectly covers alternatives by clarifying what transfer_to is for, but it doesn't explicitly point to sibling tools 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?

The description adds significant behavioral context beyond the annotations: it explains the two-step confirmation process (preview first, then confirm with exact name), the irreversibility, and the requirement to transfer transactions. The annotations only state readOnlyHint=false and destructiveHint=true, so this extra detail is valuable and consistent.

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

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

The description is concise and front-loaded: it states the action and its destructive nature in the first sentence, then explains the confirmation process and transaction transfer requirement. Every sentence adds crucial information with 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?

For a destructive tool with no output schema, the description covers the essential operational steps: preview, confirmation, and transfer. It also covers the risk of irreversibility. It does not explicitly state the return value or error handling, but given the complexity and the 100% schema coverage, the description is sufficiently complete for an agent to use it correctly.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description reinforces the purpose of 'confirm', 'confirm_name', and 'transfer_to', but does not add new semantics beyond what the schema already provides. The overlap is acceptable, hence a baseline score of 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?

The description clearly states the tool 'Delete a category group and every category in it', using a specific verb and resource. It is unambiguous and distinguishes this destructive action from sibling tools like 'update_category_group' or 'delete_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 provides clear usage context: it is destructive and irreversible, requires a confirmation step, and necessitates specifying a transfer target. It implicitly advises caution but does not explicitly name alternative tools for non-destructive needs, though the destructive nature is self-evident.

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

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

Beyond the annotations' destructiveHint and readOnlyHint, the description discloses that the operation is irreversible, that a first call only previews, and that confirmation requires an exact-name safeguard. This is substantive behavioral context an agent needs before invoking.

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

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

Two compact sentences with no filler. The core action is front-loaded, followed immediately by the critical safety requirements.

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 three-parameter tool, the description fully covers how to invoke it safely: payee identification, preview behavior, and confirmation requirements. The lack of an output schema is not a significant gap here because the focus is on the destructive action and its guardrails.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by sequencing the parameters into a safe workflow (preview first, then confirm with both confirm:true and confirm_name), which ties the parameter semantics together.

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

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

The description opens with a specific verb and resource: 'Delete a payee,' which is unambiguous and distinguishes this tool from sibling payee tools like create_payee and update_payee. The destructive/irreversible warning reinforces the operation's nature.

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 actionable usage context: the first call should preview, and actual deletion requires confirm:true plus the exact confirm_name. It does not explicitly name alternatives or say when not to use it, but the context makes the deletion workflow 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?

Beyond the destructiveHint annotation, the description adds the critical nuance that the first call only previews and actual deletion requires confirm: true, plus it explicitly labels the operation irreversible. This provides rich behavioral context that the annotations alone 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?

Two tightly written sentences: the first states the core purpose, the second delivers the critical destructive caveat and confirmation requirement. Zero filler and perfectly 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 description covers the essential behavior (purpose, destructiveness, two-step confirm) and is sufficiently complete for a simple two-parameter tool without an output schema. It doesn't describe return values or error handling, but those are not essential 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 100%, so both parameters are already documented. The description reinforces the confirm parameter's meaning by explaining the preview/confirm flow, but adds no new parameter-specific details beyond the schema. Baseline 3 is appropriate since the schema handles the 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 states a specific verb ('Delete') and resource ('transaction rule') with its identifier, making the tool's purpose unambiguous. It clearly distinguishes from sibling tools like delete_account or delete_category by targeting rules specifically.

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 deleting transaction rules, and since there is no update_rule sibling, it is the only deletion tool for rules. It lacks explicit alternatives or when-not-to-use guidance, but the context is clear enough that an agent would know when to invoke it.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the crucial 'irreversible' qualifier and explains the preview/confirm mechanism. This goes beyond the annotations and tells the agent exactly what to expect behaviorally, including the safety rail of previewing before actual deletion.

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 waste. The purpose is front-loaded, followed immediately by the critical behavioral warning. 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 destructive tool with a two-step confirm flow, the description fully equips the agent: it knows what it does, the irreversibility, and the exact call sequence. No output schema exists, but that's not a gap here. The description is complete for safe and 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% for both parameters, and the schema already documents confirm as 'Must be true to delete. Without it, the tool only previews.' The description simply restates that behavior without adding new parameter-specific meaning. Baseline of 3 applies since 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 states 'Delete a transaction by its ID' with a specific verb and resource, clearly distinguishing it from sibling tools like create_transaction and update_transaction. The ID parameter is named, and the destructive nature is immediately apparent.

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 describes the two-step usage pattern: a first call previews the loss, and a subsequent call with confirm:true executes the delete. This gives clear context for how to invoke the tool safely, though it doesn't explicitly name alternatives or when not to use it. Still, the guidance is strong and actionable.

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

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

Annotations already provide readOnlyHint=true, and the description adds useful behavioral context by specifying exactly what the response includes: category groups, categories, budgeted/actual/remaining amounts, and to-be-budgeted amount. No destructive side effects are suggested, and the description aligns with the annotation.

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

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

The description is a single, well-structured sentence that front-loads the primary action and then compactly lists the output contents. There is no filler or redundant phrasing.

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 tool with one optional parameter and no output schema, the description covers the essential return contents and scope. An agent can understand what information will be provided without needing additional details.

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

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

Schema coverage is 100%, and the month parameter is fully documented with format, natural language examples, and default behavior. The description only repeats the notion of a 'specific month' and adds no extra parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Get') and the resource ('the budget for a specific month'), and enumerates the returned content: category groups, categories, budgeted amounts, actual spending, remaining balance, and to-be-budgeted amount. It is specific and understandable, but it does not explicitly distinguish itself from similar siblings like get_budget_summary or monthly_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 gives a clear use case: retrieving budget details for a specific month, with category-level breakdown and remaining balances. It implies when this tool should be used, but it does not state exclusions or explicitly point to alternatives such as get_budget_summary for higher-level budget figures.

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

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

The readOnlyHint=true annotation is consistent with the description, and the description goes beyond the annotation by specifying the output fields and the monthly grain. It does not cover edge cases like months with no budget data, but for a read-only summary the main behavioral contract is present.

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 no filler, front-loading the core concept ('Executive summary of the budget') before a tight list of the included metrics. Every phrase contributes to the agent's understanding.

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

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

With one optional parameter, a read-only annotation, and no output schema, the description covers the core call contract: what to pass and what comes back. It does not specify currency units or the exact format of values, and the default-month behavior is only in the schema, but these are minor gaps for a summary 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 input schema fully documents the only parameter, month, including format and default behavior. The description only repeats 'for a given month' and adds no additional semantic or formatting detail, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the resource (budget) and the operation shape (an executive summary for a given month), and enumerates the key metrics returned. It is distinguishable from transaction-level tools, but it does not explicitly differentiate itself from similarly named siblings like monthly_summary or get_budget_month.

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 about when to prefer this tool over alternatives such as monthly_summary, get_budget_month, or budget_vs_actual, and it names no exclusions. The phrase 'executive summary' weakly implies high-level use, but the agent is left to infer the 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 readOnlyHint=true, and the description does not contradict that. It adds useful behavioral context by specifying that the result includes category groups, their categories, and IDs, which is especially important since no output schema is provided.

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

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

Two short sentences, front-loaded with the core behavior and followed by a brief use-case statement. 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 zero-parameter, read-only listing tool, this description is nearly complete: it states what is returned and the intended use case. It could be slightly richer about the output shape or hierarchy, but it is adequate for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the schema already fully covers parameter needs. The description does not need to explain parameters and simply clarifies the returned data scope.

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

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

Description states a clear verb and resource: list all category groups with their categories and IDs. It also conveys the hierarchical scope ('full budget structure'), which distinguishes it from account-, transaction-, and balance-focused 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?

The phrase 'Useful for seeing the full budget structure' provides clear context for when to call this tool. It does not explicitly name alternatives or exclusion conditions, but the read-only listing purpose is unambiguous.

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

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

Annotations already declare readOnlyHint=true, aligning with the 'Get' verb. The description adds minimal behavioral context beyond that—it does not mention output format, whether the current month is included, or how historical data is aggregated. With annotations covering the safety profile, a score of 3 is appropriate because the description adds only marginally to what is already explicit.

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

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

The description is a single concise sentence that front-loads the key purpose (balance and spending history) and scope (specific category, months). No filler or redundant phrasing; every element contributes to understanding.

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 no output schema, so the description should clarify the return structure. It says 'balance and spending history' but does not specify the format (e.g., array of monthly breakdowns, total balance, etc.). Given the low complexity and that params are fully documented, the gap is moderate—gaps exist for return shape and possible edges like months=0 or negative numbers. This 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%—both 'category' and 'months' are described (including the default for months). The description adds no additional meaning beyond echoing the influence of months ('across one or more months') and does not explain edge cases like month boundaries. Per the baseline for high schema coverage, a 3 is correct.

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 (get), resource (balance and spending history for a category), and scope (across one or more months). It is clear and distinguishes from the broad get_transactions or get_budget_summary, though it overlaps semantically with spending_by_category, category_trends, and balance_history without explicitly differentiating the exact meaning of 'balance' or 'spending 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?

The description implies a use case (querying a specific category over months) but offers no comparison to sibling tools like spending_by_category, category_trends, or balance_history. It does not state when to prefer this tool over alternatives or when not to use it. The context is clear enough, but guidance is missing.

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

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

The annotation readOnlyHint=true already discloses the read-only nature. The description adds that it lists all payees in the budget and that IDs are included, providing some extra context about scope and output. However, it does not describe pagination, ordering, or exact response structure, which the absence of an output schema leaves partly uncovered.

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 no fluff. The primary action is front-loaded ('List all payees'), and the added clause explains why the tool is useful without repeating 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 simple, zero-parameter, read-only tool, the description is sufficiently complete. It states the scope ('all payees in the budget') and the key output detail ('their IDs'), matching the safety profile already provided by annotations. No additional details are essential 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?

The input schema has no parameters, so there is nothing for the description to clarify. The 0-parameter baseline is 4, and the description does not need to compensate for missing parameter documentation.

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

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

The description clearly states the action ('List'), the resource ('all payees in the budget'), and the purpose ('seeing available payees and their IDs'). This is specific enough to distinguish it from sibling tools like create_payee, update_payee, and delete_payee.

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 'Useful for seeing available payees and their IDs' gives a clear use case, indicating when an agent should use this tool. It does not explicitly mention alternatives or when-not-to-use, but the context is clear enough for selection among the large 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?

Annotations already declare readOnlyHint=true, and the description's 'List' aligns with that. It adds the output scope ('conditions and actions'), which is useful, but no further behavioral details (e.g., pagination, ordering, limits). Since annotations cover the safety profile, the bar is lower, but the added value is modest.

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

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

One tight sentence that leads with the verb and resource, then specifies what is returned. 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 zero-parameter list tool with no output schema, the description gives a reasonable hint of the output ('conditions and actions') but doesn't mention other possible rule fields or result format. Still, it's adequate for a simple retrieval 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 empty input schema fully covers parameter semantics. The description doesn't need to add parameter info; baseline 4 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 verb (List), resource (transaction rules), and output content (conditions and actions). With no sibling tool named similarly, it's unambiguous and distinct from create_rule/delete_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?

Usage is implied as a read-only retrieval tool for transaction rules, but no explicit guidance is given on when to use it versus alternatives or any exclusions. The description doesn't mention prerequisites or typical scenarios.

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

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

The annotations already declare readOnlyHint: true, so the agent knows this is a safe read operation. The description adds the specific fields returned (date, payee, category, amount, notes, account, cleared status), which is useful context beyond the annotation. No contradictions exist.

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

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

Two concise sentences with no filler. The action ('List transactions') is front-loaded, and the return fields are listed compactly. 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 listing tool with 8 optional parameters, full schema coverage, and a readOnly annotation, the description covers the core purpose and return fields. It lacks details like default sorting or pagination, but these are not critical for a basic list operation, and the schema provides defaults for limit and dates. The tool is adequately specified.

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

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

The schema provides 100% coverage with descriptions for all 8 parameters, so the baseline is 3. The description adds no parameter-specific detail beyond saying 'optional filters'; it doesn't compensate further because the schema already handles parameter meaning adequately.

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 'List' and the resource 'transactions', and mentions optional filters, distinguishing it from sibling tools that create, update, or delete transactions. It also enumerates the returned fields, 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 implies this is the tool to retrieve transactions, but it does not explicitly state when to use it versus alternatives like get_budget_month or spending_by_category. There are no exclusions or alternative routing provided, leaving the agent to infer from the name and 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?

The readOnlyHint annotation already signals a safe read operation. The description adds useful context about what is returned (balances, type, status), but does not disclose details like whether inactive accounts are included, ordering, or pagination. No contradiction with annotations.

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

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

A single, front-loaded sentence that names the action, resource, and key output fields. No filler or redundant 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 zero-parameter read-only list tool, the description is nearly complete. It could mention whether the list is sorted or includes archived accounts, but the core information an agent needs to invoke and interpret the result is present.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description compensates by clarifying the output scope (all budget accounts with balances, type, and status), which is sufficient for an agent to know what the call will return.

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

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

The description states a specific verb ('List') and resource ('budget accounts'), and specifies the returned fields: current balances, type (on-budget/off-budget), and status. This clearly distinguishes it from sibling tools like create_account or get_budget_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 a read-only listing use case, and the readOnlyHint annotation reinforces that. However, it does not explicitly state when to use this tool versus alternatives like get_budget_summary or get_categories, nor does it mention any exclusions or prerequisites.

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

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

The readOnlyHint annotation already declares this as a read-only operation, and the description ('showing') is consistent. The description adds that it aggregates multiple months and highlights trends, which is useful functional context, but it does not disclose any additional behavioral details beyond the annotation. With annotations covering the safety profile, a 3 is appropriate.

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 fluff. The first sentence states the core functionality, the second gives a use case. All information is relevant and front-loaded, making it easy to parse quickly.

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 tool with one optional parameter and no output schema, the description covers the key aspects: what metrics are shown, the multi-month scope, and the intended use case. It could be slightly more explicit about the output format (e.g., per-month breakdown), but given the tool's simplicity, this is a minor gap.

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

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

Schema coverage is 100% because the single parameter 'months' has a description ('Number of months to show (default 3)'). The tool description reinforces the concept of multiple months but adds no new semantics about the parameter. Since the schema fully documents the parameter, the baseline 3 applies.

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

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

The description clearly states a specific verb ('showing') and resource ('monthly financial summary'), and lists the specific metrics (income, expenses, savings, savings rate). The phrase 'across multiple months' distinguishes it from month-specific siblings like get_budget_summary or budget_vs_actual, making the tool's scope 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 a clear usage context ('Great for seeing trends in your overall financial health'), implying when to use it. However, it does not explicitly name alternative tools or state when NOT to use it, leaving some inference required for an agent comparing 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?

Annotations provide readOnlyHint=false and idempotentHint=true, so the description doesn't need to restate those. The description adds no extra behavioral context beyond the annotations, such as whether the change is reversible, whether it affects budget calculations, or whether it requires specific permissions. With annotations covering the basic safety profile, a 3 is appropriate.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the action and resource clearly, making it easy for an agent to parse quickly.

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

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

For a simple two-parameter mutation tool with full schema coverage and annotations, the description is mostly adequate. However, it lacks guidance on how to determine valid category values (e.g., whether category accepts a name or ID, and how to resolve ambiguity), which could be important for correct invocation. The absence of an output schema is not a major issue given the simplicity.

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 parameters (transaction_id and category). The description adds no additional meaning beyond what the schema provides, such as the format of category (name vs ID) or how to find valid categories. Baseline 3 is correct 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 'Change the category of an existing transaction' clearly states the verb (change) and resource (category of an existing transaction), distinguishing it from sibling tools like create_transaction or update_transaction. It is concise and unambiguous, though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage context: it is for modifying an existing transaction's category, not for creating or deleting transactions. However, it does not explicitly state when to use this tool versus update_transaction or other category-related tools, nor does it mention any prerequisites like the transaction existing or category validity.

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, the description appropriately signals that this tool mutates state by booking an adjustment transaction. It adds useful context about the effect (clearing residual, aligning to bank balance), but does not disclose side effects such as whether a visible transaction appears in transaction lists, whether the adjustment is reversible, or whether prior reconciliations are affected.

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 packs the verb, resource, purpose, and condition without waste. It is front-loaded with the action and immediately explains why this tool 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 focused adjustment tool with fully documented parameters, the description covers the main scenario well. It lacks only minor contextual details such as what the return value is or what happens if the account is not multi-currency, but those are not critical for invoking it correctly.

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

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

The input schema already provides 100% coverage with descriptions for all six parameters, so the description does not need to repeat parameter details. The description adds no new parameter-level meaning beyond the schema, which is fine but earns only 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?

States a specific action ('Book an adjustment transaction'), the target resource ('multi-currency account'), and the goal ('bring ... to the balance the bank reports' / 'clearing accumulated FX-rate residual'). This clearly distinguishes it from general transaction-creation tools like create_transaction by specifying the reconciliation purpose.

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

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

The description gives clear context for when to use the tool: when a multi-currency account has an FX-rate residual and needs to be brought in line with the bank's reported balance. It does not explicitly name excluded alternatives or say 'use create_transaction instead', but the purpose is specific enough to imply 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 provide idempotentHint=true and readOnlyHint=false. The description adds valuable behavioral context: it rebuilds sync bookkeeping without modifying budget data, which is a key safety guarantee. It does not cover failure modes or side effects, but the added constraint justifies above-baseline scoring.

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 only three sentences and front-loads the purpose. However, the first and third sentences both express the same when-to-use condition, making the third redundant. A tighter two-sentence version would eliminate the 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?

Given zero parameters, no output schema, and annotations covering idempotency and mutation, the description provides the essential purpose and side-effect guarantee. It is complete for calling the tool correctly; minor omissions like behavior when already in sync are not critical.

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

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

The tool has zero parameters and the input schema is empty, so schema coverage is 100%. With no parameters to explain, the description cannot add parameter meaning; the baseline 4 applies.

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

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

The description states a specific action ('Repair the budget's sync state') and resource (sync bookkeeping), and explicitly notes it does not modify budget data. This differentiates it from write tools and from run_bank_sync, even without naming siblings.

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

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

The description gives an explicit trigger: 'Use this when other tools report that the budget is out of sync.' It does not name alternatives or provide when-not conditions, but the context is clear and sufficient to select the tool.

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

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

Annotations provide readOnlyHint=false, indicating this is a mutating action. The description adds provider names and scope, but does not disclose other behavioral aspects like whether the sync is asynchronous, how conflicts are handled, or if it can be safely rerun. It adds some context beyond annotations but not comprehensive behavioral detail.

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

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

Two sentences with no wasted words. The core purpose and scope are front-loaded, and the provider names are integrated naturally. It is concise yet informative, achieving maximum efficiency.

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 tool with no output schema and annotations covering the read/write nature, the description is mostly adequate. However, it misses guidance on when to use this vs repair_sync, and it does not hint at any return values or side effects (e.g., whether it updates local data). Given the existence of repair_sync, the agent may need better differentiation.

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 a single parameter 'account' with full description coverage (100%), including behavior when omitted. The description repeats this same information ('Syncs a specific account or all linked accounts if none specified'). Since the schema already fully documents the parameter, the description adds no additional semantic value, aligning with the baseline of 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?

The description states a specific verb ('Sync'), resource ('bank transactions from linked accounts'), and the providers (GoCardless/SimpleFIN). It also clarifies the scope: a specific account or all linked accounts. This makes the tool's purpose unambiguous and distinguishes it from sibling tools like repair_sync, which is about fixing sync issues.

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 ('Syncs...') but offers no explicit guidance on when *not* to use it or alternatives. For instance, it doesn't mention repair_sync for fixing sync problems or list_accounts for finding account IDs. The usage context is implied rather than explicitly 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, so the read-only nature is covered. The description adds that the tool returns total spending and percentage per category, which is useful context. However, it does not disclose details like whether transfers are excluded, how percentages are calculated, or what happens with zero-spending categories – gaps made less severe by the read-only annotation.

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

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

The description is two sentences with no filler. It leads with the core action, then states the output content. Every sentence earns its place, and the length is appropriate for the tool's simplicity.

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 fully documented parameters, the description is adequate but not complete. It mentions the output (totals and percentages) but omits any mention of how percentages are computed, whether the output is sorted, or how the limit parameter affects results. Since there is no output schema, a bit more detail on return semantics would improve completeness.

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

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

Schema description coverage is 100%, with all four parameters (limit, end_date, start_date, include_income) documented in the schema. The description adds no parameter-specific details beyond the general 'date range' phrasing, so it does not exceed the baseline set by complete schema coverage.

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

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

The description uses a specific verb ('Break down') and resource ('spending by category'), and details the output ('total spending and percentage of total'). It clearly states what the tool does, though it does not explicitly differentiate from overlapping siblings like category_trends or budget_vs_actual, which also aggregate spending.

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 category_trends, monthly_summary, or budget_vs_actual. The description only states the tool's function, leaving the agent to infer appropriate usage from the name and 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?

Annotations already declare readOnlyHint=true. The description adds useful behavioral context beyond that: the projection is based on the current daily spending rate, and the tool proactively warns about categories likely to exceed budget. It does not contradict the annotation.

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

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

Two sentences with no filler. The core purpose and distinguishing warning behavior are front-loaded, and every word contributes to the definition.

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

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

Given one optional parameter and a well-covered schema, the description is largely complete for tool selection and invocation. It explains the methodology and the warning behavior, though it does not detail the shape of the returned projection 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 coverage is 100%, including a clear description for the 'month' parameter. The tool description adds no parameter-level detail beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description names a specific verb ('Project'), a clear resource (end-of-month spending per category), and a distinct computation basis (current daily spending rate). It also includes the warning behavior, which differentiates it from siblings like spending_by_category and budget_vs_actual.

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

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

The description clearly implies when to use this tool: when you need a forward-looking spending projection based on the current pace, plus budget-exceedance warnings. It does not explicitly name alternatives or say when not to use it, but the context is sufficiently 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=false and idempotentHint=true, so the safety profile is covered. The description adds no additional behavioral context—it does not mention overwrite behavior, scope of impact, or any side effects beyond the action itself.

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. It states the action and scope efficiently, and 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 simple setter with complete schema descriptions and idempotentHint annotation, the description covers the basic purpose adequately. However, it lacks any usage context or behavioral detail beyond the action, leaving some room for improvement without being inadequate.

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

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

Schema coverage is 100%, with meaningful descriptions for all three parameters including month's default and amount format. The description itself adds no extra parameter semantics, so the baseline 3 applies.

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

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

The description uses a specific verb ('set') with a clear resource ('budgeted amount') and scope ('for a category in a specific month'). It clearly distinguishes this write operation from the many read-only budget sibling tools like get_budget_month and get_budget_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 provides no explicit guidance on when to use this tool versus alternatives, but the contrast with sibling getters makes the intended use case (modifying budget amounts) implicitly clear. There are no exclusions or alternative tool names 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 provide readOnlyHint=false and idempotentHint=true. The description only restates the tool's purpose and does not add behavioral context such as side effects, required permissions, or consequences of hiding a category beyond what annotations and the title already 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 a single, front-loaded sentence with no filler. Every word contributes to stating the tool's purpose, making it easy for an agent to parse quickly.

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 three fully documented parameters and meaningful annotations, the description is nearly complete. It lacks only a small explicit note about combining rename and hide operations or clarifying that name and hidden are optional independent actions, though the schema already conveys 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 description coverage is 100%, with clear descriptions for category, name, and hidden. The description adds no extra parameter meaning beyond what the schema already documents, so the baseline 3 applies.

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

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

The description uses a specific verb-resource pair: 'Rename or hide/unhide a budget category.' This clearly distinguishes it from sibling tools like create_category, delete_category, and update_category_group by naming the exact operations it supports.

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 based on the desired action (rename, hide, or unhide), but it does not explicitly contrast it with alternatives such as create_category or delete_category, nor does it state any exclusions or prerequisites.

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

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

Annotations already indicate readOnlyHint=false and idempotentHint=true. The description adds specific mutating behaviors (rename, hide/unhide) but does not add context on permissions, side effects on related categories, or combined-update behavior. 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, front-loaded sentence with no filler. It states both supported operations clearly and 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 simple update tool with fully described parameters, the description is largely complete. It does not explain whether name and hidden can be combined atomically or describe the return value, but these are minor gaps given the tool's simplicity.

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 parameters are already fully documented. The description adds no extra parameter-level meaning beyond aligning the actions with name and hidden, which is already in the schema.

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

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

The description uses a specific verb and resource: 'Rename or hide/unhide a category group.' It clearly distinguishes itself from sibling create/delete tools, and the action is unambiguous even next to update_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 implies when the tool is used (when renaming or hiding/unhiding an existing group), but it does not explicitly state when to use it versus create_category_group or delete_category_group. No exclusions or alternative-routing 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=false and idempotentHint=true, so the description adds little behavioral context. It does not mention whether renaming cascades to existing transactions, whether the payee must already exist, or any other side effects; the description mostly restates the title.

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 with no filler or redundant phrasing. It is front-loaded with the action, but it is minimal enough that it contributes only basic purpose, not richer guidance.

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

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

For a simple two-parameter update tool with full schema coverage and idempotency annotation, the core calling contract is reasonably clear. However, the lack of usage guidance and side-effect context leaves some ambiguity about how renaming a payee affects related data, so it is only minimally complete.

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

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

Schema description coverage is 100%, with both 'payee' and 'name' clearly documented as 'Payee name or ID' and 'New name for the payee'. The description does not need to add parameter details, so the baseline 3 applies.

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

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

The description 'Rename a payee.' states a specific verb and resource, making the tool's function immediately clear. It distinguishes itself from sibling tools like create_payee and delete_payee by expressing the update semantics 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?

The description gives no guidance on when to use this tool versus alternatives such as create_payee or delete_payee. There are no stated conditions, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool 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?

Annotations already establish that this is a mutating (readOnlyHint=false) but idempotent operation; the description adds a meaningful behavioral guarantee that unspecified fields are preserved. It does not cover return values or side effects on budgets/categories, but the partial-update disclosure goes beyond the structured metadata.

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 entire definition is a single 13-word sentence with the key behavior front-loaded. No filler or redundant restatement of the title.

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

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

For a 7-parameter mutation with no output schema, the description plus schema covers the main call contract and the partial-update semantics. It leaves ambiguous what a successful update returns and when the sibling recategorize_transaction should be preferred, but those are secondary for making 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?

All seven parameters have descriptions in the JSON schema, so the schema carries the semantic load. The description's 'only the fields you provide will be changed' reinforces optionality but does not add details about date formats, amounts, or categories 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?

Uses a specific action verb ('Update') and a concrete resource ('existing transaction'), and the phrase 'fields you provide' signals a partial edit. It does not explicitly contrast with sibling recategorize_transaction, but it is clear enough about the general 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 text implies use for modifying fields of an existing transaction and emphasizes that only supplied fields change, which orients an agent toward partial updates. It provides no explicit exclusions or mention of alternatives such as recategorize_transaction for category-only edits, so the guidance is mostly implicit.

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