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

With no annotations, the description carries the burden of disclosing behaviors. It mentions 'parallel' execution and the dry_run option, which are useful. However, it does not disclose side effects on partial failures, atomicity, response format, or required permissions, leaving significant behavioral gaps for a bulk mutation tool.

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

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

The description is two short sentences, front-loaded with the primary action. Every word contributes value, with no repetition or filler.

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

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

The tool has no output schema and a nested parameter structure. The description does not explain return values, error handling, or whether updates are atomic. Given the complexity of a bulk operation, this is a significant omission.

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 provides complete descriptions for both parameters (dry_run and updates) with 100% coverage. The tool description adds no extra parameter meaning beyond what the schema already states, so a 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 identifies the tool's function: updating multiple transactions, with the distinctive 'in parallel' behavior distinguishing it from the single-update sibling tool update_transaction. The verb 'update' and resource 'transactions' are specific.

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 batch updates via 'multiple transactions', but it does not explicitly name the alternative (e.g., update_transaction) or state when NOT to use this tool. There is no exclusion guidance, but the 'parallel' context provides some implied usage.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Create' but does not mention any side effects, required permissions, reversibility, or what happens if the group_id is invalid. This is a significant gap for a mutation tool.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. No unnecessary words or repetition.

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

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

For a simple create operation with full schema coverage, the description is minimally adequate. However, it lacks behavioral context such as outcomes or dependencies, and with no annotations or output schema, it does not fully compensate for the missing transparency.

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 each parameter already documented. The description adds marginal value by clarifying the hierarchical relationship ('within a category group'), but it does not elaborate on parameter formats or defaults 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 clearly states the action ('Create') and the resource ('a new budget category') with a specific scope ('within a category group'). It distinguishes the tool from sibling create tools like create_tag and create_transaction by naming the exact entity type.

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, no prerequisites, and no exclusions. It simply states what the tool does without context on how 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states that a manual account is created, but does not mention side effects, required permissions, validation behavior, whether the initial balance is immediately reflected, or what the tool returns. This is a significant gap for a mutation tool.

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

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

The description is a single, front-loaded sentence with no redundant wording. It is concise and immediately understandable, earning a top score.

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 5 parameters, no annotations, and no output schema, but the description is extremely terse. It does not explain return behavior, prerequisites, or any operational context beyond the basic action, leaving significant gaps for an agent selecting and invoking the 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 has 100% coverage, with all five parameters described clearly. The description adds no additional parameter-specific meaning 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 directly states the action ('Create') and the target resource ('a new manual (non-linked) account'). The qualifier 'manual (non-linked)' clearly distinguishes this tool from other account-related operations like update_account or delete_account, and 'manual' differentiates it from linked institution accounts.

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 'manual (non-linked) account' provides clear context that this tool is for creating accounts not connected to an external institution, implying a distinction from linked accounts managed via refresh_accounts. However, it does not explicitly state when not to use the tool or name alternative tools, so it does not reach a full 5.

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

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

No annotations are provided, and the description only states the basic action. It does not disclose duplicate-handling behavior, permissions, side effects, or response behavior, which is expected for a mutation tool.

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

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

The description is a single concise sentence with no fluff. It is appropriately front-loaded and easy to parse.

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

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

For a mutation tool with no annotations, no output schema, and minimal description, the context is insufficient. It does not explain success behavior, duplicate tag handling, or how the created tag can be used with other tools.

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

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

Schema coverage is 100% with both parameters (name, color) described. The description adds no further meaning beyond the schema, 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 'Create a new transaction tag.' clearly states the action (create) and the resource (transaction tag), distinguishing it from siblings like get_tags and set_transaction_tags.

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 get_tags, set_transaction_tags, or create_category. It gives no context or exclusions.

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

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

No annotations are provided, and the description fails to disclose behavioral traits such as whether creating a transaction updates the account balance (as indicated by the update_balance parameter), whether it is reversible, or any side effects. For a mutation tool, this lack of transparency is a significant gap.

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

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

The description is a single, focused sentence that wastes no words. It is appropriately front-loaded and structured.

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

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

The tool has 7 parameters, no output schema, and no annotations, yet the description only states the basic action. It omits important context such as what the tool returns upon success, any constraints on input, or the effect of the update_balance parameter.

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?

While the schema has high description coverage (86%), the tool description itself adds no parameter semantics. It does not explain how parameters relate or any additional context beyond the schema.

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

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

The description states the specific verb 'create' and resource 'manual transaction', clearly distinguishing it from siblings like update_transaction and delete_transaction. It unambiguously indicates the tool's function.

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 bulk_update_transactions or split_transaction. There is no mention of use cases or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create' without mentioning side effects, idempotency, permissions, or what happens after creation (e.g., whether the rule applies retroactively). For a mutation tool with no annotation coverage, this is a significant gap.

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

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

The description is a single, succinct sentence that conveys the core purpose and optional actions. It is front-loaded with the main action and resource, and every phrase earns its place. There is zero waste.

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

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

The tool has 13 parameters and no output schema, making it a complex creation operation. The description is minimal and does not explain the overall rule creation workflow, expected return value, or interactions with other tools. While the schema covers parameters, the description lacks the broader behavioral context needed for a tool of this complexity.

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

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

The schema descriptions cover 100% of parameters with detailed explanations. The tool description adds a high-level grouping ('Merchant pattern → category, with optional tag, hide, and review actions') that maps to parameters like merchant_criteria_value, set_category_id, add_tag_ids, hide_from_reports, and review_status. This provides context but does not add meaning beyond what the schema already offers, so the baseline 3 is appropriate.

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

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

The description clearly states the tool creates a transaction auto-categorization rule with a specific action (merchant pattern → category) and optional tags, hide, and review actions. This is a specific verb+resource combination that distinguishes it from sibling tools like update_transaction_rule or delete_transaction_rule.

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

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

The description clearly implies this tool is for creating new rules, which is evident from the verb 'create' and the resource. It provides clear context for when to use it, though it does not explicitly mention alternatives or exclusions. The sibling list includes update/delete rule tools, making the creation use-case obvious.

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

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

No annotations are provided, so the description must carry the full burden of disclosing behavioral traits. It does not mention irreversibility, cascading effects on related data (e.g., transactions), authentication requirements, or idempotency. This is a significant gap for a destructive operation.

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 is immediately understandable. No unnecessary words 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?

While the tool is simple (one parameter, no output schema), the description lacks critical context for a deletion operation. It does not explain the outcome, side effects, or error conditions. Without annotations, this leaves the agent under-informed about the consequences of invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only states 'by ID' without explaining what kind of ID (e.g., UUID, string format), where to obtain it, or any validation rules. The schema only specifies type: string, so the description adds minimal 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 ('Delete'), the resource ('an account'), and the method ('by ID'). This distinguishes it from sibling tools like get_accounts, update_account, and create_manual_account.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, consequences, or exclusions (e.g., 'Only delete accounts with no transactions'). The usage context is purely implied by the verb 'delete'.

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

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

No annotations are present, so the description carries full behavioral disclosure burden. It mentions the optional move but fails to state what happens to transactions when move_to_category_id is not provided, leaving a critical ambiguity for a delete operation.

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 two clauses, front-loaded with the primary action and no filler words.

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

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

As a mutation tool with no annotations and no output schema, the description should clarify deletion consequences and transaction handling. It does not, leaving the tool under-specified for safe use.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The description's 'move its transactions' rephrases the schema's 'move existing transactions to' without adding new semantic information.

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+resource ('Delete a category') and adds the optional move-transactions behavior, clearly distinguishing it from sibling delete tools like delete_account 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 when to use this tool (deleting a category) and when to use the optional move_to_category_id, but it does not explicitly mention alternatives or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Delete a transaction by ID' only states the core operation without indicating whether deletion is permanent, what happens to associated tags or data, or whether special permissions are needed. It offers no insight into the side effects or reversibility.

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

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

The description is a single short sentence with no redundancy or filler. It is efficiently worded and front-loads the essential information about the action and parameter.

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

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

Although the tool is simple with only one parameter, the description lacks important context such as the permanence of deletion, any side effects, or the expected return value. This makes it incomplete for an agent to fully anticipate the consequences of invoking it.

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

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

The description's phrase 'by ID' aligns with the transaction_id parameter but adds no additional meaning beyond the parameter name. Since schema coverage is 0%, the description should compensate by explaining the ID's format, source, or usage, but it does not.

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

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

The description clearly states the action (delete), the target resource (transaction), and the specific scope (by ID). This distinguishes it from other sibling tools such as update_transaction and create_transaction, which have different operations.

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

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

No guidance is given about when to use this tool versus alternatives like update_transaction or mark_transaction_reviewed. There are no prerequisites, exclusions, or recommended contexts mentioned.

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

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

No annotations are provided, so the description carries the full burden. The word 'delete' signals a destructive action, but it does not disclose additional behavioral traits such as permanence, side effects, or error handling. It is minimally transparent but lacks depth that would help an agent understand consequences.

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

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

The description is a single, well-formed sentence with no wasted words. It is front-loaded with the action and resource, making it easy to parse.

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

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

The tool is simple (one parameter, no output schema), and the description adequately states the purpose. It does not need to explain return values because there is no output schema. It could mention permanence, but given the simplicity, it is sufficiently complete for a basic delete operation.

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

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

The schema already fully documents the only parameter (rule_id) with its description. The description adds no additional meaning beyond restating that deletion is by ID, so the baseline of 3 is appropriate given the 100% 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 ('Delete'), a clear resource ('transaction rule'), and a method ('by ID'). It clearly distinguishes this tool from siblings like create_transaction_rule, update_transaction_rule, and get_transaction_rules.

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: call this tool when you have a rule_id and want to remove that rule. It doesn't explicitly discuss alternatives, but for a delete operation, alternatives are not necessary. There is no misleading guidance, and the context is clear.

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

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

No annotations exist, so the description carries the full burden. It only states the basic function and does not disclose error behavior, response format, or whether the balance is a simple number. No side effects are mentioned, though as a read operation it is implied.

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

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

The description is a single concise sentence, front-loaded with the verb and resource, and contains no redundant words. It is appropriately sized for a simple getter.

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

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

The tool is simple and the schema covers the parameter, but the description lacks usage context, expected response format, and edge-case behavior. With no output schema, the agent cannot infer the exact return shape (e.g., numeric value, currency).

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 account_id, so the schema fully documents the parameter. The description adds 'by ID' which minimally reinforces that the ID is the account identifier, but adds little beyond 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 clearly states the action (get) and resource (current balance for a specific account by ID). This distinguishes it from sibling tools like get_accounts (list accounts) and get_account_snapshots (historical snapshots).

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_accounts or get_account_snapshots. The only hint is the need for an account ID, but there is no explicit context or exclusions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does add useful behavioral context by specifying that compact returns id/name/balance/type and full returns all fields. However, it does not explicitly mention that the operation is read-only, nor does it address pagination, limits, or other potential side effects, which is a notable gap given the absence of annotations.

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

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

The description is extremely concise: two sentences with the main purpose front-loaded, followed by a clear explanation of the parameter behavior. Every word earns its place, with no repetition of schema content.

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

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

For a simple list tool with one optional parameter and no output schema, the description sufficiently covers purpose and return values. It doesn't mention pagination or ordering, but given the tool's simplicity and the richness of sibling information, this is an acceptable level of 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?

Although the schema already describes the enum with 'compact (default) or full', the description goes beyond by detailing what each verbosity value actually returns (compact: id/name/balance/type; full: all fields). This adds meaningful semantic value for the agent invoking the tool.

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

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

Description 'Get all accounts.' clearly states the verb (get) and resource (accounts) with scope (all), which distinguishes it from siblings like get_account_balance or get_account_snapshots. It does not explicitly name alternatives, but the purpose is specific and unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_account_balance or get_complete_financial_overview. It only explains the verbosity parameter, with no context for selection or exclusions, so it fails to help the agent choose among the many get_* 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?

No annotations are provided, so the description carries the full burden. It does not disclose return format, whether it includes all accounts, pagination, or any side effects. The description essentially rephrases the tool name without adding meaningful behavioral context, leaving the agent uncertain about what the call will return or if it is safe.

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 unnecessary words. It efficiently states the core purpose without redundancy, making it easy to parse and remember.

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 lack of annotations, no output schema, and zero parameter descriptions, the description provides insufficient context for correct invocation. The agent does not know the expected response structure, date format, or any constraints. While the purpose is clear, the operational details needed to use the tool reliably are missing.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that start_date and end_date define a date range, but provides no format (e.g., YYYY-MM-DD), inclusivity semantics, or any detail about the two parameters. The agent cannot confidently construct valid input without additional information.

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 action ('Get'), resource ('account balance snapshots'), and scope ('for a date range'). This distinguishes it from siblings like get_account_balance (which likely returns current balance) and get_net_worth, making the purpose unambiguous.

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

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

The phrase 'for a date range' clearly implies this tool is for retrieving historical snapshots over a specified period, providing context on when to use it. However, it does not explicitly mention alternatives or exclusions like 'for current balance use get_account_balance', so it falls short of full 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?

No annotations are provided, so the description must disclose any relevant behavior. The description only states the data returned (planned vs actual by category) and does not clarify whether it includes all categories, how it handles missing budgets, or if it is purely read-only. As a simple getter, the risk is low, so a score of 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 concise sentence that front-loads the core purpose. Every word contributes, making it efficient and easy to parse.

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 two optional parameters, the description covers the purpose and the schema covers parameters. However, there is no output schema, and the description does not specify the output structure (e.g., list, object) or whether it includes zero values, leaving some ambiguity. Overall adequate for its complexity, but not maximally complete.

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

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

The input schema fully documents both parameters with descriptions and defaults, so the description adds no additional semantic value. Baseline of 3 applies due to 100% 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 tool retrieves budget planned vs actual amounts broken down by category. This is specific enough to distinguish it from sibling tools like get_spending_by_category or get_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 provides no guidance on when to select this tool over alternatives. There is no mention of scenarios or exclusions, so the agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and input scope, without disclosing behavior like how dates are processed, whether results are aggregated, or what the response structure looks like.

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, front-loaded with the verb and resource, with no redundant words. It efficiently conveys the core purpose.

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

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

The tool is simple with two well-documented parameters, but the lack of output schema and annotations means the description must provide more context. It states the core purpose but does not explain the response format or edge cases, making it minimally 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?

Both parameters are described in the schema with identical semantics ('Natural language or YYYY-MM-DD'), yielding 100% coverage. The description adds no additional parameter-level meaning beyond the schema.

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

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

The description clearly states the tool retrieves a cashflow summary covering both income and expense for a specified date range, using a specific verb and resource. This distinguishes it from sibling tools like get_spending_summary by explicitly including income.

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

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

No explicit guidance is provided on when to choose this tool over similar summary tools. The description implies a date-range use case but does not mention alternatives or exclusions, leaving the agent to infer suitability.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Get...' without explaining return format, side effects, or whether it is read-only beyond the verb's implication. No additional behavioral context is offered.

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 redundant words. It efficiently conveys the core purpose 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 simple 0-parameter tool, the description is adequate, but it lacks information about the response structure or usage context. Since there is no output schema, the description should clarify what the returned categories and category groups look like, which it does not.

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 description adds meaning by specifying 'all categories and category groups,' clarifying the scope and that the result includes both entities. This aligns with the baseline for 0-param tools.

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 'Get all categories and category groups,' which clearly identifies the action (get) and the resource (categories/category groups). This distinguishes it from sibling tools like get_tags, which target a different resource.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that this is the go-to for listing categories, nor does it note when to use get_tags or other category-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions analyzing and suggesting, but it does not explicitly state that this is a read-only operation, whether it modifies transactions, or any prerequisites such as requiring merchant history. It adds some context about using historical data but still leaves side-effect and permission questions unanswered.

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 purpose and includes output details. Every element contributes to understanding the tool without unnecessary verbosity.

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 absence of an output schema, the description compensates by listing return fields (transaction ID, merchant, suggested category, confidence, history count). It also explains the core logic. It does not cover edge cases like empty history or default behavior, but the 100% schema coverage for parameters and moderate complexity make this reasonably complete. The lack of explicit usage guidance prevents a 5.

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

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

The input schema already provides 100% coverage with descriptions for all four parameters. The description does not add additional semantic meaning beyond what the schema already gives, though it does mention 'history count' in the output, which relates to history parameters. Baseline 3 is appropriate because the schema handles 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 tool's function: analyzing uncategorized and needs-review transactions and suggesting categories based on merchant history. It specifies the input scope (uncategorized/needs-review), the method (history-based), and the output fields, distinguishing it from sibling tools like get_uncategorized_summary or get_transactions_needing_review.

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 does not explicitly state when to use this tool versus alternatives. It implies usage for category suggestions, but it never mentions when not to use it or references sibling tools like get_uncategorized_summary or search_transactions. No usage context or exclusions are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only lists data categories and says nothing about side effects (though likely a read-only operation), response format, data freshness, or any caveats. This lack of behavioral detail leaves the agent uncertain about safety and expectations.

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

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

The description is a single sentence that front-loads the core value ('Comprehensive financial overview') and then efficiently enumerates the covered areas. Every word earns its place, and it is appropriately sized for a tool with no parameters and no complex behavior.

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

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

Given the tool's low complexity (no parameters, no output schema), the description provides a reasonable overview by listing the major data sections. However, it does not specify the exact return structure or whether the data is summarized or detailed. Since there is no output schema, the description could have added a bit more about the shape of the response, but it is largely sufficient for an agent to anticipate a combined payload.

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 schema is an empty object, so schema coverage is trivially 100%. According to the baseline rule for 0-parameter tools, a score of 4 is appropriate—there are no parameter semantics for the description to clarify, and the description 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 clearly identifies the tool as a comprehensive financial overview that aggregates accounts, net worth, cashflow, budgets, and recurring transactions. The phrase 'in one call' distinguishes it from the many single-purpose sibling tools like get_accounts, get_net_worth, and get_budget_summary, making the purpose unmistakable.

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

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

The description implies when to use this tool: when you need a broad, combined financial picture without making multiple separate calls. It does not explicitly name alternatives or exclusion criteria, but the 'in one call' phrasing strongly suggests it replaces calling several individual tools, which is clear contextual 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?

With no annotations provided, the description must disclose behavioral traits, but 'Get savings goals' only indicates a read operation. It does not state what is returned, whether all goals are included, or any error conditions, leaving the agent with minimal behavioral information and no indication of pagination, rate limits, or data structure.

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

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

The description is extremely concise at three words, with no wasted content. For a zero-parameter getter, this brevity is appropriate, though it borders on under-specification by omitting any structural 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 tool lacks an output schema and annotations, so the description must explain return values and context to be complete. It does not, leaving significant ambiguity about what constitutes a 'goal' and the structure of results, making this minimally sufficient only for the simplest case.

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 an empty schema, so the description does not need to explain parameter details. The 100% schema coverage and absence of parameters merit a baseline score of 4, as the schema already fully describes the (lack of) parameters.

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

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

The description 'Get savings goals' clearly states a verb ('Get') and a specific resource ('savings goals'), which distinguishes it from sibling tools focused on transactions, accounts, or budgets. However, it lacks any detail about scope (e.g., all goals vs. one) or return format, so it is clear but not richly informative.

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 about when to use this tool versus alternatives like get_budget_summary or get_spending_summary. The description only states the operation with no context, prerequisites, or exclusions, leaving the agent without direction on selecting this 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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states what the tool retrieves ('connected financial institutions and credential status') but does not explicitly say whether it is read-only, whether it requires existing connections, or what side effects (if any) exist. The 'get' verb implies read-only, but the description does not confirm this or provide any additional behavioral context.

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

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

The description is a single sentence that is concise and front-loaded with the verb 'Get'. Every word adds meaning, with no filler or redundancy. It is an ideal length for a simple retrieval tool.

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 tool, the description provides the basic purpose but lacks some context. It does not explain what 'credential status' entails, whether the result is a list or single object, or any nuances about connected institutions. Since there is no output schema, the description should offer more detail about the return value and any relevant behavior, but it remains minimally viable.

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

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

The tool has zero parameters, so the baseline score is 4. The description adds no parameter information, but none is needed since the input schema is empty. The description's focus on output (institutions and credential status) is sufficient for a parameterless tool.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource: 'connected financial institutions and credential status.' This distinguishes it from sibling tools like get_accounts or get_tags by focusing on institutions and their credential state. The purpose is unambiguous and directly matches the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or mention of sibling tools such as get_accounts or refresh_accounts. The context of when this tool is appropriate is entirely absent.

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

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

No annotations are provided, so the description carries the full burden. 'Get details' implies a non-mutating read operation, and 'including recurring stream configuration' hints at the return structure. However, it doesn't disclose behaviors like error handling for missing merchant_id, response format, or any potential side effects, which would be valuable for an unannotated tool.

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

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

The description is a single, focused sentence that front-loads the primary action ('Get details') and follows with a key qualifier. Every word adds value and there is no verbose or redundant content.

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

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

Given this is a simple getter with one parameter and no output schema, the description provides a reasonable starting point but lacks detail on return values beyond 'recurring stream configuration'. It doesn't mention error conditions or whether the response includes other merchant metadata, which would be reasonably expected when 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?

The input schema lists merchant_id as a required string with no description, and the schema description coverage is 0%. The tool description only says 'for a specific merchant', adding little beyond the parameter name itself. It doesn't clarify whether merchant_id is an internal ID, a slug, or a UUID, leaving the agent to guess the correct value format.

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 the specific verb 'Get' and clearly identifies the resource as 'a specific merchant', with the additional qualifier 'including recurring stream configuration' that adds useful scope beyond the tool name alone. This distinguishes it from sibling tools like update_merchant and get_recurring_transactions.

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

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

The description states what the tool does but provides no guidance on when to use it versus alternatives. There is no mention of exclusions, prerequisites, or references to related tools such as update_merchant or get_recurring_transactions, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden. It states a read operation but discloses no behavioral traits such as whether the month default is applied, whether accounts are pre-filtered, or how savings is calculated. This lack of detail is a notable gap for a tool with zero annotation coverage.

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 directly states the tool's function without wasted words. It is front-loaded and easy to parse, earning a perfect score for conciseness.

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

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

Despite the tool's simplicity, the description lacks contextual completeness because it does not clarify how this tool differs from several similar sibling tools (e.g., get_spending_summary, get_cashflow). With no output schema or annotations, the description should provide more context about the return structure or scope, but it remains minimal.

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 covers the only parameter 'month' with a description and default behavior, so the tool description adds no extra meaning. Since schema coverage is 100%, 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 states a specific verb ('Get') and resource ('income, expenses, and savings for a specific month'), making the tool's function obvious. However, it does not explicitly distinguish itself from sibling tools like get_spending_summary or get_cashflow, which could overlap in 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 implies usage for retrieving a monthly summary but provides no explicit guidance on when to choose this tool over alternatives. There is no mention of exclusions or conditions, leaving the agent to infer appropriateness from the name alone.

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

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

No annotations are provided, so the description carries the burden. It discloses the computation method ('total assets minus liabilities') but does not explicitly state that it is a read-only operation or describe any side effects. The 'get' prefix implies safety, but explicit behavioral context is limited.

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, clear sentence with no redundancy. It front-loads the action and defines the key concept efficiently.

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

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

Given the tool's simplicity (no params, no output schema), the description sufficiently explains what it returns (net worth). It could optionally mention the return format (e.g., currency amount), but for a trivial getter, it is adequately complete.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter information because none exist, but it does not need to compensate. The schema fully covers the empty parameter set.

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 'Get' and the resource 'net worth', and defines it as 'total assets minus liabilities'. This well-defined scope distinguishes it from sibling tools like get_account_balance or get_complete_financial_overview.

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: use when you need the current net worth. It does not explicitly mention alternatives or exclusions, such as when to use get_complete_financial_overview instead. The guidance is minimal but 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states 'Get,' which implies a read-only operation, but it doesn't mention any side effects, authorization requirements, rate limits, or what the return payload contains. For a tool that likely queries investment data, this is minimal transparency beyond the verb 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?

The description is a single, front-loaded sentence that states the core function without waste. It contains no redundant or repetitive information, making it appropriately concise for a simple 'get' 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?

Given that there are no annotations, no output schema, and parameters with zero documentation, the description is too thin to be complete. It doesn't clarify what 'holdings and performance' includes, how the date range is applied, or what the response structure looks like. The tool likely needs more contextual explanation to be fully usable by an agent.

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

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

Schema description coverage is 0%, and the description fails to explain the meaning or purpose of the start_date and end_date parameters. The description doesn't mention date ranges or how they affect the result. Since the schema provides no descriptions, the description needed to compensate but did not, leaving parameters entirely unexplained.

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 ('Get') and a specific resource ('investment portfolio holdings and performance'), which distinguishes it from sibling tools like get_accounts or get_net_worth. It precisely conveys the tool's purpose without ambiguity.

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. With many sibling 'get' tools (e.g., get_net_worth, get_account_balance), there's no context or exclusion criteria explaining when a user should prefer get_portfolio. This absence makes it hard for an agent to select the right 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It states 'Get', which implies a read-only operation, but it does not describe output format, whether it includes future/past streams, or how 'recurring' is determined. This is minimal but not misleading.

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: 'Get recurring transaction streams (subscriptions, bills, income).' It is concise, grammatically clear, and contains no filler words.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description adequately explains the core function. However, it could be improved by mentioning what the returned streams look like (e.g., fields, frequency), as there is no output schema to convey that. Still, for a zero-param getter, it is reasonably complete.

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

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

The tool has zero parameters, and the schema is empty, so there is nothing to explain. Per the rubric, 0 params warrant a baseline score of 4, and the description does not need to add any parameter semantics.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('recurring transaction streams'), and provides concrete examples (subscriptions, bills, income) that distinguish it from sibling tools like get_transactions, which fetch all transactions.

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

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

The examples (subscriptions, bills, income) imply the tool is for recurring items, giving some usage context. However, it does not explicitly mention when to use this vs. alternatives, nor does it indicate exclusions (e.g., 'for general transactions, use get_transactions').

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

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

Since no annotations are provided, the description carries the burden of showing behavior. It correctly implies a read-only, analytical nature by saying 'suggest new rules' and 'input for create_transaction_rule' (not the rule creation itself). It also discloses the return structure. It could add more detail on defaults or exclusions, but the schema covers some of that.

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

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

The description is two concise sentences: purpose, output fields, and usage hint. Every sentence carries functional value, with no wasted words.

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

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

For a 4-parameter tool with no output schema and no annotations, the description adequately conveys purpose, output shape, and workflow. It could mention default exclusions or lookback behavior, but the schema handles that. The description is overall sufficient for an agent to select and invoke the tool.

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

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

Schema coverage is 100% with detailed descriptions for all four parameters, so the baseline is 3. The description adds thematic context ('recent transactions', 'consistent category pattern') that aligns with lookback_days, min_confidence, and min_transactions, but it does not add specific parameter meaning beyond the schema.

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

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

The description clearly states the tool analyzes recent transactions and suggests new rules for merchants with consistent category patterns. It specifies the output fields (merchant pattern, suggested category, confidence score, transaction count) and distinguishes itself from siblings like get_transaction_rules by focusing on rule candidates rather than existing rules.

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 a clear usage context by labeling the output as 'High-value input for create_transaction_rule', implying it is used before creating a rule. However, it does not explicitly mention alternative tools or when not to use it, such as comparisons with get_categorization_suggestions.

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

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

With no annotations, the description carries the full burden. It discloses read-only behavior through 'Get' and aggregation behavior via 'broken down by category', plus date filtering. However, it does not mention return format, whether uncategorized transactions are included, or date range inclusivity, leaving some behavioral gaps.

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

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

The description is a single, front-loaded sentence of ten words. It contains no filler, redundancy, or extraneous information, making it maximally concise.

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 two well-documented parameters, no output schema, and no nested objects, the description is largely complete. It states the input scope and the output grouping. Minor gaps remain about exact response structure and handling of uncategorized data, but these are not critical for a straightforward read operation.

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

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

The input schema provides 100% parameter coverage with descriptions for start_date and end_date, so the description need not repeat syntax. It adds only the context that these dates bound the spending range, which is a baseline contribution.

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 the specific verb 'Get' with the resource 'spending' and qualifies it with 'broken down by category' and 'for a date range'. This makes the tool's purpose clear and distinguishes it from sibling tools like get_spending_summary or get_uncategorized_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?

No explicit guidance is given for when to use this tool versus alternatives. The date-range hint implies a temporal scope, but no exclusions or alternative tool names are mentioned, leaving the agent to infer selection criteria from sibling names alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It outlines the analysis dimensions but fails to mention how date range parameters affect the output, whether the operation is read-only, or what the returned data structure looks like. No side effects or caveats are disclosed.

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

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

The description is a single sentence that is front-loaded with the core purpose and key breakdown dimensions. It contains zero fluff and states the primary function efficiently.

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 lack of annotations and output schema, the description must be more comprehensive. It covers the output axes but omits parameter semantics, usage context, and behavioral details, leaving the agent with insufficient information to confidently invoke the 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 has two string parameters (start_date, end_date) both lacking descriptions, and schema description coverage is 0%. The description does not mention either parameter or clarify how the date range influences the summary, providing no additional meaning beyond the bare parameter names.

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

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

The description clearly states the tool provides a multi-axis spending analysis broken down by category, category group, and merchant, along with overall income/expense/savings. This specific scope distinguishes it from sibling tools like get_spending_by_category and get_complete_financial_overview.

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 about when to use this tool versus alternatives. It doesn't mention a preferred use case, nor does it contrast with related tools such as get_spending_by_category or get_budget_summary, leaving the agent to infer applicability.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action (get) but does not disclose return format, pagination limits, ordering, or any side effects. This is insufficient for an agent to know what to expect from the call.

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

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

The description is a single concise sentence, front-loaded with the action and resource. Every word earns its place with no unnecessary filler.

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

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

The tool has no output schema, so the description should at least hint at the return shape (e.g., list of tag names/objects). It does not. Additionally, there is no mention of usage context or differentiation from related tools, leaving the description incomplete for reliable 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 zero parameters, so the baseline is 4. The description adds no parameter-specific details, but none are needed since the tool takes no arguments.

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 the specific verb 'Get' and clearly identifies the resource as 'all transaction tags.' This distinguishes it from sibling tools like get_categories by explicitly naming the resource type (tags vs. categories).

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

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

No explicit guidance on when to use this tool versus alternatives, but the usage is clearly implied: use it to retrieve transaction tags. There is no mention of when not to use it or any alternative recommendation.

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

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

No annotations are provided, so the description alone must disclose behavior. The verb 'Get' clearly indicates a read operation, but it doesn't mention any additional behavioral context such as response format, ordering, or potential performance implications. This is adequate for a simple read-only tool.

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

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

The description is a single, focused sentence 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 tool with no parameters and no output schema, the description adequately states the tool's purpose and the type of data returned. It isn't exhaustive about return value details, but the simple nature of the tool makes this sufficient.

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

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

There are zero parameters, so the description needs to provide no parameter semantics. The baseline of 4 applies, and the description adds no parameter information since none are needed.

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

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

The description uses a specific verb ('Get') and resource ('transaction auto-categorization rules') and specifies the content ('criteria and actions'), clearly distinguishing it from rule creation/update/delete and rule candidate retrieval.

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

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

No explicit when-to-use guidance or alternatives are mentioned. The word 'all' implies retrieving existing rules, but there is no differentiation from 'get_rule_candidates' or other rule-related operations.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful context: natural language date parsing and compact default format. However, it omits expected behaviors like pagination, sorting, default date window, and that the tool is read-only.

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 front-loaded purpose. Every phrase contributes meaningful behavior—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 an 8-parameter tool with no output schema, this description is somewhat thin. It lacks guidance on default date ranges, sort order, or how the response is structured. The presence of a search_transactions sibling further underscores the need for more contextual differentiation, but the core listing behavior is conveyed.

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

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

Schema coverage is 100%, so the baseline is 3. The description repeats what the schema already states (natural language dates, verbose/compact format) without adding new parameter-level meaning. It does not clarify defaults or interactions beyond schema descriptions.

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

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

The description clearly states 'Get transactions' with a specific verb and resource, and adds distinctive capabilities (natural language dates, compact format by default). However, it does not differentiate from the sibling search_transactions, so it lacks full sibling distinction.

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

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

The description provides no guidance on when to use this tool instead of search_transactions or other transaction-related tools. It does not mention alternatives, exclusions, or recommended contexts for use.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only mentions 'compact format by default', implying a verbose option, but does not explain pagination, ordering, date filtering, or what 'needs review' means in terms of status. The read-only nature is implied by 'get', but other behaviors are unexplained.

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

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

The description is two short sentences, front-loaded with the core purpose and a useful default behavior. Every word earns its place, with no fluff or repetition.

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

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

Given four optional parameters and no annotations or output schema, the description should clarify the meaning of 'all', the effect of date ranges, limit behavior, and what fields appear in compact vs verbose mode. It does none of this, leaving the agent to infer crucial invocation details.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters (limit, verbose, start_date, end_date). It only hints at 'verbose' via 'compact format by default' and says nothing about the other parameters. This is insufficient.

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

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

The phrase 'Get all transactions that need review' clearly identifies the tool's function and distinguishes it from generic transaction retrieval tools like get_transactions. The resource ('transactions') and state ('needing review') are explicit, though the scope of 'all' (accounts, date ranges) is not specified.

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_transactions, search_transactions, or get_categorization_suggestions. It does not state whether it includes all accounts or if it should be used alongside review-related tools.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does state that the tool aggregates counts by month, but it does not explicitly confirm it is read-only, mention permissions, or describe the return structure. The behavior is implied but not fully detailed.

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

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

The description is two short sentences, front-loaded with the primary action. Every word earns its place, and it is free of unnecessary detail or repetition.

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

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

For a simple tool with one optional parameter and no output schema, the description provides adequate context. It explains the tool's grouping by month and its use case. However, it is ambiguous whether 'uncategorized' and 'needs-review' counts are reported combined or separately, and the return format is not explicitly stated. Minor gaps exist but 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 input schema already provides 100% coverage for the single parameter 'lookback_months' with a clear description and default value. The tool description adds the 'by month' context but does not elaborate on parameter syntax or additional semantics beyond what the schema states.

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 counts uncategorized and needs-review transactions by month, which is a specific verb and resource. However, it does not explicitly distinguish itself from sibling tools like get_transactions_needing_review, so it lacks explicit sibling differentiation.

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

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

The phrase 'Useful for understanding categorization backlog' provides a clear use case and context for when to use the tool. It does not mention when not to use it or alternative tools, so it falls short of explicit exclusion 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?

With no annotations, the description must fully disclose behavior. It states the core effect (sets needsReview = false) but omits side effects, error behavior, partial success handling for multiple IDs, or whether the operation is idempotent. This is similar to the 'MID' example where mutation tools without annotations received a low score due to missing contextual 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 a single sentence, directly stating the action and effect with no unnecessary words. It front-loads the verb and resource, making it immediately clear and 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 simple mutation tool with 2 parameters and no output schema, the description and schema provide enough to invoke the tool. However, it lacks return value expectations, error handling, and confirmation of whether both parameters can be used together, leaving some ambiguity for an agent.

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

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

Schema coverage is 100% with clear descriptions for each parameter ('Single transaction ID' and 'Multiple IDs'). The tool description adds minimal semantic value beyond the schema, only implying that one can pass either a single ID or multiple IDs. It does not clarify exclusivity or behavior when both are provided, but the schema already covers the basics.

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 ('Mark') and clearly identifies the resource ('transactions') and the exact state change ('needsReview = false'). It effectively communicates the action and scope ('one or more'), but does not explicitly differentiate from sibling tools like update_transaction or bulk_update_transactions that could also modify this field.

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: it's for clearing the needsReview flag, likely after using get_transactions_needing_review. However, it provides no explicit guidance on when to use this tool versus update_transaction or bulk_update_transactions, nor does it mention any prerequisites or alternatives.

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

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

With no annotations, the description must disclose behavioral traits on its own. It does mention the default behavior (all active linked accounts) but omits important operational details such as whether the refresh is asynchronous, how long it might take, whether it modifies stored data, or what the response contains. This is a significant gap for an action-oriented tool.

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

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

The description is two sentences, front-loaded with the core action and followed by the optional parameter behavior. Every word earns its place, with no redundancy or filler.

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

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

The tool is simple with one optional parameter and no output schema, so the description covers the essentials. However, it does not explain what the caller should expect after making the request (e.g., a success status, asynchronous job ID, or error behavior), which is a small but notable gap given the absence of an output schema.

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

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

The schema already documents the sole parameter completely (100% coverage), so the baseline is 3. The description adds semantic value by explicitly stating that omitting account_ids means all active linked accounts will be refreshed, which is a meaningful behavioral clarification not present 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 clearly states the tool's function with a specific verb ('request') and resource ('data refresh for linked accounts'), distinguishing it from the many read-only getter siblings. It also clarifies the scope (all active accounts by default), adding precision beyond a simple action statement.

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 usage context is implied: it is the only refresh tool among siblings, so an agent can infer when to use it. However, the description does not explicitly state when to use it versus alternatives, nor does it mention any when-not-to-use conditions or prerequisites, leaving the guidance implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Search transactions,' which implies a read-only operation, but it does not describe the return format, pagination, sort order, case sensitivity, or how limit and verbose affect behavior. This is a significant transparency gap.

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

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

The description is a single, clear, front-loaded sentence. It avoids unnecessary words and effectively communicates the core purpose and key optional input in a compact form.

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

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

With five parameters, no annotations, and no output schema, the description is too sparse. It provides the search criteria but omits details about return values, limit/verbose semantics, pagination, and any behavioral nuances. The description leaves the agent with important gaps in understanding how to invoke the tool effectively.

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 only documents the 'query' parameter. The description adds meaning by clarifying that query is a keyword or merchant name and that date range is optional, which helps interpret start_date and end_date. However, the 'limit' and 'verbose' parameters remain undocumented and the description does not fully compensate for the low schema coverage.

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

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

The description clearly states that this tool searches transactions by keyword or merchant name, with an optional date range. It is specific enough to indicate the resource and search criteria, but it does not explicitly distinguish itself from sibling tools like get_transactions.

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

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

The description implies that the tool is appropriate when you need to find transactions by keyword or merchant name within a date range. However, it provides no explicit guidance on when to use this tool versus alternatives like get_transactions, and it does not mention exclusions.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure, but it only says 'Set' without explaining consequences like overwriting existing budgets, permission requirements, or handling of missing category/group IDs. This is a minimal mutation description similar to the update_drive example.

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 action and target. It contains no wasted words and is easily 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?

Despite having 5 parameters and no output schema, the description is only one sentence. It does not explain relationships between parameters (e.g., whether category_id and category_group_id are mutually exclusive), nor what the caller should expect as a response, leaving the tool incomplete for a setter.

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

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

The input schema covers 100% of parameters with descriptions, so the baseline applies. The description adds marginal value by mentioning both category and category group, which aligns with category_id and category_group_id, but adds no new semantic details.

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

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

The description clearly states the tool's function with a specific verb ('Set') and resource ('monthly budget amount'), and specifies the target scope ('category or category group'). This distinguishes it from sibling getter tools like 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, nor any prerequisites or exclusion criteria. It only implies usage by stating what it does, which is minimally sufficient for a straightforward setter.

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

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

With no annotations provided, the description carries the full burden. It discloses the key behavioral trait: that all existing tags are replaced, and how to clear them. This is the most critical side effect for an agent to know. It doesn't cover return values or error cases, but for a simple mutation tool, the core behavior is well disclosed.

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

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

Two sentences, each packed with essential information. It is front-loaded with the main action and immediately states the critical replacement behavior. No wasted words.

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

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

For a simple two-parameter tool with no output schema or annotations, the description covers the action, the replacement semantics, and the clearing case. It doesn't discuss return values, but that is not essential for selection or correct invocation. It is nearly complete for the tool's complexity.

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

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

Schema coverage is 50%, with tag_ids having a generic description and transaction_id having none. The description adds crucial semantics for tag_ids by explaining the replacement behavior and that an empty array clears tags. transaction_id's purpose is inferable from the tool name and context, so the description partially compensates for the gap.

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

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

The description clearly states the verb ('Set') and resource ('tags on a transaction'), and the critical behavior 'REPLACES all existing tags' distinguishes it from sibling tools like create_tag or update_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 gives clear context for when to use the tool: to set tags by replacing existing ones, with explicit instruction for clearing ('Pass empty array to clear'). It doesn't name alternatives, but the replacement semantics imply when not to use it (e.g., if you want to append tags).

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

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

The description discloses important behaviors: the sum constraint and the empty-array removal mechanism. However, with no annotations provided, it fails to state whether existing splits are replaced or merged, or what effects this has on the transaction's tags/categories.

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

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

The description is three short sentences, front-loaded with the main purpose, with no redundant filler. Every sentence adds meaningful information.

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

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

Given the lack of annotations and output schema, the description covers the primary behavior but omits important details such as whether existing splits are replaced, return value, and any preconditions. This is a meaningful gap for a mutation tool.

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

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

Schema coverage is 0% for top-level parameters, so the description must compensate. It adds the constraint that split amounts must sum to the original, and that an empty array removes splits. However, it does not describe the structure of each split element or the meaning of transaction_id beyond the obvious.

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 the specific verb 'split' with the resource 'transaction' (e.g., 'Split a transaction into multiple parts'), which clearly distinguishes it from sibling tools like update_transaction or create_transaction. The main action 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?

It states the core use case (splitting a transaction) and provides a condition ('Sum of split amounts must equal original') and an alternative mode ('Pass empty splits array to remove splits'). However, it does not explicitly mention when not to use it or how it compares to update_transaction.

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

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

No annotations are provided, so the description must carry the full burden. It only lists a few possible updates (rename, toggle net worth, hide) without disclosing side effects, permissions, reversibility, or partial-update behavior. The schema reveals additional behaviors like display_balance and hide_transactions_from_reports that the description omits.

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

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

A single sentence with no filler, front-loaded with the primary action. It communicates the key capabilities in minimal space.

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

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

With six parameters, no annotations, and no output schema, this is a complex update tool that deserves more detail. The description under-specifies the full scope of updates and fails to mention several modifiable fields, making it incomplete for an agent to understand the tool's full impact.

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

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

The description adds meaning for include_in_net_worth ('toggle net worth inclusion') and hide_from_list ('hide it'), which partially compensates for the 50% schema coverage. However, display_balance and hide_transactions_from_reports remain undescribed in both schema and description, so the compensation is incomplete.

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

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

The description clearly states the tool's actions: renaming an account, toggling net worth inclusion, and hiding it. This distinguishes it from sibling tools like delete_account and get_accounts, and uses specific verbs tied to a resource.

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

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

The usage is implied: this is an update tool for accounts, but no explicit guidance is given about when to prefer it over alternatives like delete_account or refresh_accounts. The context signals list siblings but the description omits any direct comparison or exclusions.

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

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

Annotations are entirely absent, so the description carries the full burden. It does disclose a notable behavioral trait: the rename is 'global', meaning it affects the merchant system-wide. However, it does not explain side effects, permission requirements, reversibility, or how the recurring stream settings interact with existing transactions. While the global scope is meaningful, the description is sparse on deeper behavioral implications.

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, tightly constructed sentence that front-loads the primary action and scope. Every word contributes: 'globally' signals impact, and the parenthetical lists the key updatable fields. No fluff 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?

With 7 parameters and no output schema, the description is moderately thin. It provides a high-level purpose but does not explain how parameters like is_recurring and is_active interact, what the call returns, or any side effects. Given the tool's complexity, the description covers the essential selection criteria but leaves room for more operational detail.

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

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

Schema description coverage is 100% – every parameter has a description. The tool description adds no new semantic meaning beyond what the schema already provides; it merely mentions 'frequency, amount, base date' which are identical parameter names. According to the rubric, a baseline of 3 is appropriate when the schema fully describes the parameters, and the description does not elevate this.

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

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

The description clearly states the tool's function with specific verbs ('Rename', 'update') and identifies the exact resources affected ('merchant globally', 'recurring stream settings'). It distinguishes itself from read-only sibling tools like get_merchant and from update_transaction by focusing exclusively on merchant-level updates.

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 primary use cases (renaming a merchant or adjusting recurring stream settings) but provides no explicit guidance on when to avoid this tool, prerequisites, or alternatives. The 'globally' hint gives some context, but there is no mention of using get_merchant for reading or when not to update. The usage context is clear but lacks exclusions or alternative recommendations.

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

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

No annotations are provided, so the description carries full responsibility. It only lists updatable fields without disclosing whether it performs a partial update, what happens on invalid IDs, permission requirements, or reversibility. This is thin for a mutation tool.

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

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

A single concise sentence front-loaded with the action. It is efficient and compact, though the field list is somewhat redundant with the schema.

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

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

For a 9-parameter mutation with no annotations and no output schema, this description is minimal. It does not cover update semantics, error handling, or return values, making it incomplete for an agent to use reliably.

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 shorthand names like 'category' and 'merchant' but omits goal_id and does not add meaning beyond the schema's property 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 uses the specific verb 'Update' and identifies the resource 'transaction', listing seven updatable fields. It clearly indicates this is a modification tool, distinguishing it from create/delete, though it doesn't explicitly differentiate from bulk_update_transactions or mark_transaction_reviewed.

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 vs alternatives. It does not mention that it handles a single transaction, nor does it refer to bulk_update_transactions for multiple transactions or to mark_transaction_reviewed for that specific action.

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

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

With no annotations provided, the description must disclose behavior, but it only says 'Update an existing transaction rule by ID.' It does not explain whether updates are partial or full replacements, side effects, permission requirements, or idempotency. The presence of 13 optional parameters implies complex behavior that is entirely undisclosed.

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

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

The description is a single sentence that is front-loaded and free of redundancy, earning its place as a clear albeit minimal statement. However, it lacks substance needed for a complex tool, but that is a completeness issue, not a conciseness flaw.

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 tool has 14 parameters, no annotations, and no output schema, yet the description is just one line. It does not explain return values, update semantics, or the purpose of the many fields. A complex update operation requires far more context than this minimal description provides.

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

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

Schema description coverage is only 7% (only rule_id is described), and the description adds no meaning for the other 13 parameters. It fails to explain critical fields like account_ids, add_tag_ids, amount_value, review_status, or apply_to_existing. The 'by ID' phrase merely restates the rule_id parameter without adding depth.

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 updates an existing transaction rule by ID, using a specific verb ('Update') and resource ('transaction rule'). It distinguishes from sibling tools like create_transaction_rule and delete_transaction_rule by indicating it's for modifying existing rules.

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 vs alternatives. It doesn't mention conditions, prerequisites, or cases where create/delete would be more appropriate. The only hint is the 'by ID' qualifier, but no explicit context or exclusions.

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