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

The description adds context beyond the minimal idempotentHint annotation by identifying the resource as the 'supported manual-crypto list' and the input as a CoinGecko URL. However, it does not disclose what happens on duplicate submission or invalid URLs, so behavioral transparency is moderate.

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 consists of two sentences, is front-loaded with the primary action, and contains no unnecessary details. Every word contributes to understanding the tool's purpose and usage.

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

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

For a single-parameter mutation with no output schema, the description sufficiently explains the operation and its use condition. It does not describe the response or error behavior, but the overall context is adequate for a tool of this simplicity.

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

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

The input schema provides a complete description of the coingecko_url parameter, including the URL format and an example, so the tool description adds no extra semantic value beyond repeating that it is a CoinGecko URL. 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 the action ('Add a new cryptocurrency to the supported manual-crypto list') and the method ('by submitting its CoinGecko coin-page URL'). It also distinguishes the tool from the sibling get_supported_cryptocurrencies by specifying when it is needed.

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

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

The description explicitly provides a usage condition: 'Only needed when get_supported_cryptocurrencies does not already list the symbol you want to track.' This names the alternative tool and gives clear guidance on when to use this one.

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 behavioral details beyond the minimal annotations: reads from the host's local filesystem, determines type by content, rejects non-image/PDF files, enforces a 10MB limit, and honors the LUNCHMONEY_ATTACHMENTS_DIR restriction. This goes beyond what the idempotentHint: false annotation conveys and prepares the agent for validation errors and environment-specific behavior.

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

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

The description is three sentences with no wasted words. The first sentence states the core purpose, the second lists allowed types, and the third covers constraints (filesystem, content detection, and directory restriction). Every sentence contributes valuable 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?

The description thoroughly covers the tool's constraints and environmental dependencies. However, since there is no output schema, it would be beneficial to state what the tool returns upon success (e.g., an attachment object or ID). Despite this minor gap, the description is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema descriptions cover all four parameters fully, but the tool description adds extra meaning not present in the schema: the 10MB capacity constraint and the rule that the type is determined from actual contents (which affects file_path and content_type semantics). This provides useful selection and invocation 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 uses a specific verb ('Attach') and clearly identifies the resource ('a local image or PDF receipt to a transaction'). It is unambiguous and easily distinguishes this tool from siblings like 'get_transaction_attachment_url' and 'delete_transaction_attachment' based on the action it performs.

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 attaching receipts but does not explicitly state when to use this tool over alternatives or provide exclusions. Sibling tools for getting/deleting attachments exist, but the description does not mention them or give conditions for choosing this tool, so guidance is only implied.

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

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

The annotations only provide `idempotentHint: false`, but the description does not elaborate on behavioral traits like side effects, state changes, or error conditions. It explains the `children` mechanism but offers no transparency beyond what the schema implies.

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

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

The description is a single, well-structured sentence that efficiently covers the core functionality and key conditional rules, with no extraneous 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?

The description adequately covers the main decision points (category vs group) given the tool's complexity and absence of output schema. However, it does not mention return values, error scenarios, or validation conflicts (e.g., setting both `is_group` and `group_id`).

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 schema coverage is 100%, the description adds significant value by explaining the conditional logic between `is_group`, `group_id`, and `children`. It clarifies that `children` can be existing IDs or new names, which is not evident from individual parameter descriptions.

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

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

The description clearly states the tool creates a new 'category' or 'category group', with specific guidance on using `is_group`. It distinguishes the two modes and mentions `children` for groups, effectively differentiating from sibling tools like `update_category` or `get_single_category`.

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

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

The description provides clear guidance on when to use `is_group=true` vs `false`, and that `children` is only valid for groups. However, it lacks explicit when-not or alternative tool recommendations (e.g., using `get_all_categories` to check existing groups).

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

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

Annotations provide only idempotentHint: false. Description lacks details about side effects, permissions, limits, or the nature of 'manually-managed'. It does not clarify behavior beyond creation.

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: one sentence plus a parentheses. It is front-loaded with the essential purpose and a rename note. Every word is earned.

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 10 parameters, no output schema, and minimal description, the tool lacks return value details, field dependencies (e.g., balance_as_of with balance), and does not differentiate from the update sibling.

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 each parameter described. The description adds no extra meaning beyond the schema, so it meets the baseline.

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

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

The description clearly states the action ('Create') and the resource ('manually-managed account'), with a note about legacy naming. It distinguishes from sibling tools like update_manual_account and delete_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 on when to use this tool versus alternatives. It does not mention prerequisites, when not to use, or conditions for use. The description simply states the action without context.

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

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

Annotations only include idempotentHint: false, which covers non-idempotency. The description contributes a behavioral constraint (symbol must match supported currencies) but does not disclose other side effects, permissions, or return behavior. There is no contradiction with annotations.

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

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

Two short sentences, each earning its place: the first states the action and resource, the second adds an indispensable prerequisite. No fluff.

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

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

For a create tool with 5 parameters and no output schema, the description provides the core purpose and a key prerequisite, but it omits information about return values, duplicate behavior, or what 'manually-managed' implies relative to synced assets. The schema covers parameters, but high-level behavioral completeness is only 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?

Schema coverage is 100%, so each parameter already has a detailed description. The tool description adds no new parameter-level semantics beyond repeating the symbol constraint already present in the schema. 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 uses a specific verb ('Create') and resource ('a manually-managed crypto asset'), clearly distinguishing it from sibling tools like create_manual_account or synced crypto tools. The added constraint about symbol matching supported cryptocurrencies further clarifies its scope.

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

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

It clearly indicates the action (creating a manual crypto asset) and provides a key prerequisite (symbol must come from get_supported_cryptocurrencies). However, it does not explicitly mention when to use this over alternatives like synced crypto creation, nor does it specify any exclusions.

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

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

Annotations already indicate non-idempotent behavior, so the description adds no new behavioral context. No mention of error conditions, uniqueness, or side effects beyond creation.

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?

Single sentence with no extraneous words. Efficient and front-loaded.

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

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

For a simple creation tool with no output schema, the description could mention return value or uniqueness constraints. Current description is adequate but not complete.

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

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

Schema covers 100% of parameters with descriptions, so the description does not add extra meaning. 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 'Create a new tag.' clearly specifies the verb (create) and resource (tag), and it distinguishes from sibling tools like 'update_tag' and 'delete_tag'.

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

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

No guidance on when to use this tool over alternatives (e.g., update_tag) or when not to use it. The description is too minimal to guide selection.

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 reveals that source transactions become hidden from get_transactions and are accessible via the group's children, which is a behavioral side effect not captured by annotations or schema. It also states restrictions on split/recurring transactions, adding significant transparency.

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

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

Three well-structured sentences: first defines core purpose, second explains behavioral effect, third states restrictions. No unnecessary words, each sentence adds value.

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

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

The description covers key behavioral aspects and restrictions. While it lacks return value details and error scenarios, the absence of an output schema and the complexity of the tool make this acceptable. It is adequately complete 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?

With 86% schema coverage, the description adds value beyond the schema by explaining constraints for ids (2-500, no split/recurring) and inheritance behavior for category_id. It does not repeat schema details but enhances understanding.

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

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

The description clearly states the action (create) and resource (transaction group) with specific constraints (2-500 existing transactions). It effectively distinguishes from sibling tools like create_transactions and delete_transaction_group.

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 provides clear context on when to use (grouping existing transactions) and restrictions (cannot include split or recurring). It also explains how to access the group's children, but lacks explicit alternatives for when not to 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?

The description adds value beyond the annotations by stating the batch limit and return behavior (including duplicates). Although the annotation indicates non-idempotency (idempotentHint=false), the description doesn't contradict it. It could further detail side effects like partial failures, but overall it provides useful 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, concise sentence that communicates the core functionality and key constraints without unnecessary 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 batch creation tool with multiple behavioral options and no output schema, the description covers the basic return and limit but omits error handling, partial success scenarios, and a more detailed explanation of duplicate detection (e.g., external_id deduplication). It is adequate but not fully complete.

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

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

Schema coverage is 100% with detailed parameter descriptions, so the description adds minimal new semantic meaning beyond the bulk limit and deduplication note. Baseline score of 3 is appropriate as the description doesn't significantly enhance understanding of the 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 clearly states the verb 'Insert', the resource 'transactions', and specifies the batch size range (1-500). It also mentions the return value includes inserted transactions and skipped duplicates, distinguishing it from the singular 'create_transaction' sibling.

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 guide when to use this tool versus alternatives like 'create_transaction' for single inserts, nor does it provide context on when to set parameters like apply_rules or skip_balance_update. Usage is implied but not fully clarified.

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

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

Beyond the destructiveHint annotation, the description adds that the operation is 'irreversible' and 'affects the Net Worth views,' giving valuable behavioral context. There is no contradiction with annotations; in fact, it reinforces them.

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

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

The description is two sentences, front-loaded with the action and scope ('Delete ALL historical balance entries'), and immediately points to an alternative. Every word earns its place.

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

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

Given the simple delete operation, full schema coverage, and the destructiveHint annotation, the description covers scope, irreversibility, and impact on Net Worth. It does not mention the response format, but with no output schema and a straightforward mutation, this is a minor gap.

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

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

The input schema provides full descriptions for both parameters with 100% coverage, so the baseline is 3. The description adds the phrase 'single account' but does not provide any new parameter-specific details beyond what the schema already offers.

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') with specific resource ('ALL historical balance entries') and scope ('for a single account'), and explicitly contrasts with the sibling tool by saying 'To remove a single month, use delete_balance_history_entry instead.' This distinguishes the tool from alternatives.

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

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

Provides explicit when-to-use guidance by naming the alternative for partial deletion: 'To remove a single month, use delete_balance_history_entry instead.' Also notes the irreversible impact on Net Worth views, helping the agent decide when to invoke 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?

With destructiveHint=true already present in annotations, the description adds useful context by explaining the historical/current distinction and the requirement for an id. It does not contradict the destructive hint and provides additional behavioral constraints beyond what annotations state.

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

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

The description is two sentences with the action front-loaded. It conveys all necessary information without any redundant or irrelevant 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 one-parameter destructive tool with no output schema, the description is complete. It explains the exact source of the id and the constraint that current entries cannot be deleted, which is sufficient for the agent to use the tool correctly.

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

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

Schema description coverage is 100%, and the entry_id parameter is already fully described in the schema, including where to find ids. The main description reinforces the historical type constraint but does not add significant new meaning beyond what the schema already 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 ('Delete'), the resource ('a single historical balance entry'), and the method ('by its id'). It also distinguishes from sibling tools like delete_account_balance_history by specifying 'historical balance entry' and 'single'.

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

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

The description explicitly states when to use the tool: the id must come from an entry with type=historical in a balance history response. It also provides a when-not ('ephemeral current entries have no id and cannot be deleted') and directs the user to call get_balance_history or get_account_balance_history first to discover ids, which is a clear prerequisite.

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 mark it as destructive. The description adds crucial details: default failure with structured 'dependents' payload, force delete is irreversible, and disassociation from related entities. No contradictions.

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

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

Three concise sentences. First states the primary action, then the two behavioral modes. No redundant 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 two simple parameters, no output schema, and the destructive annotation, the description covers all necessary points: action, default behavior, force behavior, and irreversibility. It's 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 already covers both parameters with descriptions. The description enriches 'force' by explaining its effect (disassociate from related budgets, transactions, etc.), adding value beyond the schema.

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

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

The description specifies the exact action ('Delete a single category or category group') and distinguishes between two modes (default fails with dependencies, force=true deletes). This clearly differentiates it from sibling tools like delete_tag or delete_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?

The description explains when to use the default behavior (fails if dependencies) and when to use force=true (to delete despite dependencies). It does not explicitly compare to alternatives but provides clear 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?

The description adds that deletion is irreversible and impacts Net Worth views, which goes beyond the destructiveHint annotation by specifying consequences. It also underscores the scope ('ALL'), providing valuable 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?

Two concise sentences, front-loaded with the action, no filler. Each sentence adds critical information.

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

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

For a destructive bulk delete with clear annotations and complete schema, the description covers the essential behavior and consequences. It lacks explicit mention of return values, but that's acceptable for a delete tool without an output schema.

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

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

All parameters are documented in the schema with meaningful descriptions (e.g., symbol as ticker, account_id as synced crypto account). The description does not add additional parameter-level detail, and with 100% schema coverage, 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 uses the specific verb 'Delete' with the resource 'ALL historical balance entries for a synced crypto holding,' clearly differentiating it from siblings like delete_balance_history_entry by emphasizing 'ALL' and 'synced crypto holding.'

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 context (irreversible, affects Net Worth) but does not explicitly state when to use this tool over alternatives like delete_balance_history_entry or delete_account_balance_history. Usage must be inferred from the name and scope.

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

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

Annotations already provide destructiveHint=true. The description adds that both deletion options are irreversible, reinforcing the destructive nature. No additional behavioral details (e.g., permissions, side effects) are needed given the annotation.

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

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

Two sentences convey purpose, optionality, and irreversibility with zero waste. The information is front-loaded and every word earns its place.

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

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

For a destructive tool with no output schema and full schema coverage, the description is complete enough. It does not explain return values or error states, but the user can infer behavior from the annotations and schema. Adequate for the context.

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

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

Schema coverage is 100%, so the schema describes parameters fully. The description restates the optional effects (delete_items, delete_balance_history) but adds no new semantics beyond the schema, earning a baseline score of 3.

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

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

The description clearly states the verb 'delete' and resource 'manually-managed account', distinguishing it from sibling delete tools targeting different resources (e.g., delete_category, delete_transaction). It specifies optional deletion of related items, leaving no 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 explains when to use the optional parameters (delete_items, delete_balance_history) by naming the associated data. It does not explicitly exclude cases when not to use the tool, but the resource specificity makes usage clear.

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

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

Beyond the destructiveHint annotation, the description adds that deletion is irreversible and that the API rejects requests if keep_history is not set when balance history exists. This provides important 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?

Two sentences that lead with the action and quickly cover critical caveats; no fluff.

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 delete tool with destructiveHint and no output schema, the description covers the core behavior, the key conditional requirement, and irreversibility. It is sufficient for an agent to invoke correctly.

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

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

Schema descriptions cover both parameters fully. The description repeats the keep_history condition but does not add new semantic 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 uses a specific verb+resource ('Delete a manually-managed crypto asset'), clearly distinguishing it from other delete tools for transactions, categories, accounts, etc.

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 manually-managed crypto balances but does not explicitly state when to use this tool versus alternatives like delete_manual_account or deletion of synced crypto. It provides a conditional prerequisite about keep_history but no guidance on tool selection.

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

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

Annotations already declare destructiveHint=true, indicating the tool is destructive. The description adds value by explaining the default failure behavior (HTTP 422 with dependents payload) and the effect of force=true (delete and disassociate). It does not specify if the operation is reversible, but the schema param force description calls it 'irreversible'. Overall, it provides useful behavioral context beyond annotations.

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

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

The description is extremely concise with two sentences. It front-loads the primary action ('Delete a tag') and then provides essential details about default behavior and the force option. Every part is informative with no redundancy.

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

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

Given the tool's simplicity (delete with optional force) and the presence of schema descriptions for both parameters, the description covers the main behavioral aspects: default failure condition and force behavior. There is no output schema, but for a delete tool, return values are often standard (e.g., success/error) and may not need elaborate description. The description is sufficiently complete for an agent to use the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the effect of the force parameter: 'Set force=true to delete and disassociate from those records.' This clarifies the consequence beyond the schema's 'irreversible' label. The tagId parameter is clear from the schema. The description adds moderate 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 'Delete a tag' with specific verb and resource. It distinguishes itself from sibling delete tools like delete_category, delete_manual_account, etc., by naming the resource 'tag'. The additional details about default failure and force option further clarify the tool's 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 explains when to use force=true versus the default behavior. It describes that by default, deletion fails with a dependents payload if the tag is in use, and force=true disassociates the tag. However, it does not explicitly mention when not to use the tool or suggest alternative tools, though for a delete operation the use case is self-evident.

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

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

Combined with annotations (destructiveHint: true), the description adds 'Irreversible' and failure conditions for split/group transactions. While not exhaustive (e.g., no mention of cascading effects on attachments), it provides sufficient behavioral context for safe invocation.

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?

Extremely concise with three sentences: main action, failure case with remedy, and irreversibility. No wasted words, all essential information front-loaded.

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

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

For a simple deletion tool with one parameter, no output schema, and annotations present, the description covers purpose, failure scenarios, and permanence. It is complete for the complexity level.

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

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

Schema coverage is 100% and the description does not add meaning beyond the schema's parameter description ('ID of the transaction to delete'). Baseline of 3 is appropriate as the schema already documents the parameter adequately.

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

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

Description clearly states 'Delete a single transaction', specifying the action and resource. It also provides constraints about split/group transactions, distinguishing it from siblings like delete_transactions_bulk and delete_transaction_group.

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

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

Explicitly states when the tool fails ('Fails for split/group transactions and their parents') and provides an alternative action ('unsplit/ungroup first'), offering clear guidance for appropriate 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?

Annotations already have destructiveHint: true. The description adds 'Irreversible', which reinforces the destructiveness but does not add new behavioral context beyond what the annotation provides. No contradiction.

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

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

Extremely concise: two short sentences with no filler. The key action and consequence are front-loaded. Every word earns its place.

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

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

Given the simplicity of the tool (single delete operation) and no output schema, the description covers the essential action and irreversibility. However, it lacks context about the relationship to transactions or where to obtain the file_id. Adequate but not thorough.

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

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

Schema coverage is 100% with a clear description for file_id. The tool description adds nothing beyond the schema. Parameter semantics are sufficiently covered by the schema, so 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?

Clearly states the verb 'Delete' and the resource 'transaction file attachment'. Distinguishes it from sibling tools like delete_transaction (deletes a whole transaction) and get_transaction_attachment_url (retrieves attachment URL). No 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?

Provides no guidance on when to use this tool versus other deletion tools. No mentions of prerequisites, alternatives, or when not to use it. Agent must infer context from the name alone.

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

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

Annotations already mark destructiveHint=true. The description adds essential behavioral context: child transactions remain and revert to ungrouped, which is not evident from the annotation alone. This goes beyond the annotation to clarify the non-destructive aspect for child entities.

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

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

Two sentences with no superfluous information. The key action and behavior are front-loaded, making it efficient for an AI agent 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?

Given the simple parameter schema and no output schema, the description fully covers what the tool does, its effect, and what happens to related data. No gaps remain.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add significant new meaning beyond the schema's parameter description, which already identifies the ID as belonging to the group parent transaction. The tool description reinforces but does not extend 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 'Delete (ungroup) a transaction group' and distinguishes itself by explaining that child transactions are not deleted but revert to ungrouped. This differentiates it from sibling tools like delete_transaction.

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

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

It provides clear context for when to use (to ungroup a transaction group) and explains the effect on child transactions. However, it does not explicitly mention when not to use or suggest alternatives, such as using delete_transaction to remove child transactions entirely.

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

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

Beyond the destructiveHint annotation, the description adds critical behavioral details: failure conditions for split/group IDs, required pre-processing, and irreversibility.

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

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

Two concise sentences with front-loaded action and constraints, 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?

The description covers purpose, constraints, and failure conditions well; however, it omits the return value or success indicator, which is minor for a 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?

Schema coverage is 100%, and the description adds no further parameter details beyond what the schema already 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 'Bulk-delete transactions by ID (1-500)' with a specific verb and resource, distinguishing it from single-transaction delete siblings.

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

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

It explicitly mentions when the tool fails and prerequisite actions ('unsplit or ungroup those first'), providing clear context but not explicitly naming alternatives like delete_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?

The annotation readOnlyHint=true already signals a safe read operation, lowering the bar. The description adds useful context about prerequisite discovery calls and the alternative for synced crypto, but does not disclose additional behavioral traits like pagination, return format, or handling of deleted accounts. This is a modest but not rich contribution.

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

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

Two sentences, front-loaded with the core action, then prerequisite and alternative. Every sentence earns its place with no redundant phrasing.

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

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

For a relatively simple read-only tool with a well-specified schema, the description covers the main purpose, prerequisites, and a clear alternative. It does not explain the 'deleted' account type or month format, but these are already documented in the schema. The only minor gap is a lack of mention that account_type 'deleted' exists, but this is not necessary for the primary use 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?

Schema coverage is 100%, with all four parameters described in the input schema. The description does not add parameter-specific semantics beyond mentioning that accounts must be discovered first, which relates to account_id. This matches the baseline 3 for high 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 opens with a specific verb+resource: 'Get monthly balance history for a single account.' It clearly distinguishes from the synced crypto alternative by name, making the tool's scope obvious. This meets the 5 criteria for specific and differentiated 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?

Explicit guidance is given: call get_all_manual_accounts, get_all_plaid_accounts, or get_all_manual_crypto first to discover ids, and use get_crypto_synced_balance_history for synced crypto holdings instead. This directly addresses when to use and when not to use the tool.

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

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

Annotations already declare readOnlyHint=true, so the description adds value by stating alphabetical ordering. However, it does not mention potential pagination or limits, which would be beneficial for large datasets.

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

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

Two concise sentences with no wasted words. The key information (list, user account, alphabetical order) is front-loaded and efficiently communicated.

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 simplicity of the tool (no output schema, two optional params), the description covers the core behavior adequately. It could mention that results are paginated or limited, but for most use cases it is 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?

Schema coverage is 100% with detailed descriptions for both parameters. The description adds no additional parameter semantics beyond what the schema provides, so 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 the action ('Get a list of all categories') and the resource ('categories associated with the user's account'), with additional detail about alphabetical ordering. This distinguishes it from siblings like 'get_single_category' (which retrieves one) and mutation tools.

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

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

The description implies usage for retrieving all categories but does not explicitly state when to use or not use this tool versus alternatives. No guidance on filters or when to prefer 'get_single_category' is provided.

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

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

Annotations already provide readOnlyHint=true. Description adds that it returns a list and mentions the former name, but does not disclose other traits like pagination or data format.

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

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

Single sentence with a parenthetical note, highly concise and front-loaded with the main action.

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

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

For a simple list tool with no parameters and no output schema, the description is fairly complete. It could mention pagination or output format, but the core purpose is clear.

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 has 0 parameters, so baseline is 4. Description does not need to add parameter meaning; it correctly describes the output.

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 clearly states it gets a list of manually-managed accounts, using specific verb and resource. It distinguishes from sibling tools like get_all_plaid_accounts and get_single_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 on when to use this tool versus alternatives (e.g., get_all_plaid_accounts) or when not to use it. The description only mentions the former name 'assets'.

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

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

The readOnlyHint annotation covers the safety profile, and the description adds the scoping context of 'associated with the user' and 'manually-managed.' However, it does not disclose potential pagination, return format, or other behavioral details, which would be useful for a list-returning endpoint.

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 clearly conveys the action and target. Every word earns its place, with no redundant or vague 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?

This is a simple zero-parameter, read-only tool with no output schema. The description sufficiently states what it does and the scope, though it leaves the exact return structure unstated. Given the low complexity, this is nearly 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?

There are zero parameters in the input schema, so there is nothing to explain. The baseline of 4 applies as the description cannot add parameter-related meaning beyond what the empty schema already conveys.

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

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

The description states a clear verb ('Get'), a specific resource ('manually-managed crypto balances'), and a scope ('associated with the user'). It distinguishes from sibling tools like get_all_synced_crypto (manual vs synced) and get_single_manual_crypto (all vs single).

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 are no explicit exclusions or references to sibling tools like get_all_synced_crypto or get_single_manual_crypto, leaving the agent to infer usage from the name alone.

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

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

Annotations already provide readOnlyHint=true, so the safety profile is clear. Description adds 'synced' context but no other behavioral traits (e.g., pagination, ordering).

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?

Single, front-loaded sentence with no unnecessary words. High 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?

Given no params, simple read-only operation, and no output schema, the description is fully adequate. It specifies scope and source (Plaid synced accounts).

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?

No parameters in input schema, so schema description coverage is 100%. Description doesn't need to add parameter info; baseline 4 for zero-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?

Description clearly states the tool gets a list of all Plaid (synced) accounts, using a specific verb ('Get') and resource. It distinguishes from siblings like get_all_manual_accounts and get_single_plaid_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 explicit guidance on when to use this tool vs alternatives. The sibling names imply choices, but the description lacks when-to-use or when-not-to-use instructions.

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

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

Beyond the readOnlyHint annotation, the description explains that synced accounts are web-app connected and not API-editable, adding meaningful context about data origin and constraints. It also mentions the nested per-symbol balance structure, providing additional behavioral detail without being verbose.

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: the first front-loads the primary purpose, the second adds essential context about the data source and limitations. 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 zero-parity, read-only list tool with no output schema, the description adequately conveys what is returned (synced accounts and per-symbol balances) and the operational context (web-app connected, not API-editable). It is complete for its simplicity.

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

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

The tool has zero parameters and an empty input schema, so schema coverage is 100%. The description doesn't need to explain parameters; the baseline for 0 params is 4, and this is met.

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 all synced crypto accounts with their nested per-symbol balances. It distinguishes from siblings by specifying 'synced' versus manual accounts and 'all' versus single account tools.

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

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

The description provides context that synced accounts are connected via the Lunch Money web app and cannot be created/edited via API, implying this tool is for read-only retrieval of such accounts. It does not explicitly name alternatives but clearly sets expectations for when this tool applies.

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

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

Annotations already indicate readOnlyHint=true. Description adds no further behavioral details (e.g., pagination, sorting, or effect). Consistent but not additive.

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?

Single sentence, front-loaded, no redundant words. Perfectly concise for a simple list 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?

Despite no output schema, description adequately describes return value (list of tags). No other context needed for this simple tool.

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

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

No parameters exist; description does not need to add parameter info. Baseline score for 0 params is 4.

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 clearly states verb (Get), resource (tags), and scope (user's account). It distinguishes from siblings like create_tag, delete_tag, update_tag, and get_single_tag.

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

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

No guidance on when to use this versus alternatives like get_single_tag or other tools. No context on prerequisites or use cases.

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

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

Beyond the readOnlyHint annotation, the description discloses important behavioral details: history is monthly, 'With no month range, returns all available history plus an ephemeral `current` entry for the current month, which is calculated on demand and may change between requests', and 'Only months with data are included'. This is rich, valuable context about dynamic data and scope that annotations do not convey. No contradiction with annotations.

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

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

The description is two sentences, front-loaded with the primary purpose, and each sentence adds meaningful detail. There is no redundant or filler content. It efficiently conveys scope, data frequency, default behavior, and a caveat about the current month entry.

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 a read-only tool with two optional parameters and no output schema, the description covers the essential information needed for correct invocation: scope (all accounts), frequency (monthly), default range behavior (all history + ephemeral current), and filtering of months with no data. It is sufficiently complete for an agent to select and call this tool correctly.

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

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

The input schema covers both parameters (start_month and end_month) with detailed descriptions, including format, inclusivity, and constraints. The description adds only that 'no month range' returns all history, which is already implied by optional parameters. Since schema coverage is 100%, the baseline is 3, and the description does not materially enhance parameter understanding 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 explicitly states 'Get monthly account balance history across all accounts', providing a specific verb, resource, and scope. It also distinguishes from siblings like get_account_balance_history by emphasizing 'across all accounts', and mentions its role as 'the data behind the Net Worth views', adding context. This clearly differentiates it from other balance history tools.

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

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

The description clearly implies when to use this tool (for all-account balance history) and explains behavior for no month range. However, it does not explicitly mention alternatives for per-account or crypto-specific balance history, such as get_account_balance_history or get_crypto_synced_balance_history. It provides clear context but no explicit 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?

Annotations already provide readOnlyHint=true, so the description need not restate safety. The description adds value by enumerating the specific settings returned, which is useful behavioral context beyond the annotation.

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

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

The description is a single, well-structured sentence that front-loads the purpose and lists key fields with no unnecessary 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?

With no parameters and readOnlyHint provided, the description covers the tool's purpose and return fields adequately. While it could mention the zero-param nature, the simplicity makes it sufficiently 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?

There are zero parameters, so the baseline is 4 per guidelines. The description does not need to add parameter info; the schema coverage is 100% and no parameters exist.

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 'budget period and display settings' with a specific list of fields. The tool name 'get_budget_settings' uniquely identifies it among siblings like 'get_budget_summary', establishing clear differentiation.

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

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

The description does not explicitly state when to use this tool or provide exclusions or alternatives. However, given the self-explanatory name and sibling tools, usage context is implied but not formally guided.

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

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

The description adds value beyond the readOnlyHint annotation by specifying the underlying endpoint (v2 GET /summary) and mentioning that include_occurrences returns a per-period breakdown. It does not contradict the annotation, and while it doesn't discuss rate limits or auth, the read-only nature is already indicated.

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

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

The description is very concise (two sentences) and front-loaded with the core purpose. Every sentence contributes useful information, with no redundant or wasted words.

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

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

Given the tool's complexity (7 parameters, no output schema), the description covers the main functionality and hints at return structure via field listings. However, it could be more complete by explaining the response format (e.g., top-level structure). Since schema descriptions are detailed, this is a minor gap.

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

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

The schema already provides descriptions for all 7 parameters (100% coverage). The description adds meaning for include_occurrences ('per-period breakdown matching the account's budget periodicity'), which goes beyond the schema. This extra context justifies a score above the baseline 3.

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

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

The description clearly states the tool's purpose: 'Get a summary of the user's budget for a specified date range.' It lists the specific fields returned (e.g., other_activity, recurring_activity) and mentions optional behavior (include_occurrences). This clearly distinguishes it from sibling tools like get_budget_settings or upsert_budget.

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 by naming the endpoint and specifying input parameters, but it does not explicitly state when to use this tool versus alternatives (e.g., when to use get_budget_summary vs. get_budget_settings). However, the purpose is unambiguous enough that an agent can infer 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?

With readOnlyHint=true already indicating a safe read operation, the description adds useful behavioral context: the tool returns monthly history and is scoped per symbol. It does not disclose return format or edge cases, but the annotations cover the safety profile, so this is adequate.

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

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

The description is two focused sentences, front-loaded with the primary purpose, and contains no redundant or irrelevant 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?

The description covers the tool's purpose, scoping, and relationship to a sibling tool, while the schema handles parameter details. It omits return format, but for a read-only history getter with no output schema, the provided context is sufficient for an agent to use it correctly.

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

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

The schema fully documents all four parameters with descriptions, so the baseline is 3. The description only reiterates that the tool uses account_id and symbol as identifiers and implies monthly granularity, adding little 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 monthly balance history for a synced crypto holding, identified by account_id and ticker symbol. It also explicitly distinguishes this from get_account_balance_history, making it easy to select the correct tool.

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

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

The description explicitly names the alternative (get_account_balance_history) and explains that synced crypto is scoped per symbol, so it is not available through that tool. This provides clear guidance on when to use this tool, though it does not discuss other potential 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?

Annotations declare readOnlyHint=true, and the description adds that the matches object is populated based on the requested range, providing behavioral context beyond the annotation. No contradictions.

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

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

The description is two sentences, front-loads the core purpose, and contains no redundant information. It is optimally 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?

Given no output schema and three optional parameters, the description adequately covers the tool's purpose and key behavior (matches population). However, it could mention the return format or any default behavior for omitted date ranges.

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

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

The schema has 100% coverage, so the baseline is 3. The description adds value by explaining that start_date and end_date control the matches population, which is not evident from the schema alone.

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 list of recurring items for a date range, and distinguishes it from the sibling get_single_recurring_item by indicating it returns multiple items with populated matches.

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 use for retrieving lists of recurring items over a range, but does not explicitly contrast with alternatives like get_single_recurring_item or specify prerequisites (e.g., if the user has recurring items).

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

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

Annotations already declare readOnlyHint=true, and description adds that category groups include children, providing useful behavioral context beyond annotations.

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

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

Single sentence, front-loaded with action and resource, efficiently includes additional detail about children for groups without 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?

For a simple tool with one parameter and no output schema, the description covers the purpose, parameter semantics, and behavior, leaving no gaps.

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

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

Schema description coverage is 100% and description adds context about prerequisite (get_all_categories), adding meaning beyond the schema field description.

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

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

Description clearly states the verb 'Get details' and the resource 'single category or category group', and distinguishes from sibling tools like get_all_categories by specifying it retrieves children for groups.

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

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

Provides a prerequisite hint ('Call get_all_categories first to discover ids') but does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

Annotations already provide readOnlyHint: true, so the description does not need to restate safety. It adds minimal behavioral context beyond the obvious read 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 extremely concise with one sentence, no wasted words. Every part earns its place.

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

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

Given the single parameter, high schema coverage, and readOnlyHint annotation, the description is complete for a detail retrieval tool. No output schema exists, but it is not necessary.

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

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

Schema coverage is 100% with a parameter description. The description adds valuable context by instructing to call get_all_manual_accounts first, which aids correct usage.

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 it gets details of a single manual account by ID. It is specific and distinguishes from sibling tools like get_all_manual_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 description advises calling get_all_manual_accounts first to discover IDs, which provides clear usage guidance. It implies when to use this tool but lacks explicit when-not 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?

The readOnlyHint annotation already declares the operation as read-only, and the description ('Get') aligns with that. The description adds the 'manually-managed' scope and the discovery workflow, but otherwise does not disclose additional behavioral traits such as error handling, response format, or potential absence of data. Given the annotation coverage, this is adequate but not enriched.

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 action, and includes a directly actionable follow-up instruction. Every word contributes value, with no unnecessary fluff.

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

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

This is a simple one-parameter get operation with a readOnlyHint annotation, and the description provides the essential workflow hint (call get_all_manual_crypto first). While there is no output schema or detailed return value description, the simplicity of the tool and the offered guidance make the description adequately complete for the agent to select and invoke it correctly.

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

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

The schema already provides 100% coverage for the single parameter crypto_id with a clear description ('Id of the manual crypto balance to retrieve'). The tool description essentially restates this with 'by ID,' adding no new semantic meaning beyond the schema. Baseline of 3 is appropriate for full schema coverage.

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

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

The description clearly states the function: 'Get a single manually-managed crypto balance by ID.' It uses a specific verb ('Get') and identifies both the resource type ('manually-managed crypto balance') and the key distinguishing factor ('by ID'), which differentiates it from siblings like get_all_manual_crypto and get_single_synced_crypto.

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

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

The description provides clear usage context by instructing to 'Call get_all_manual_crypto first to discover ids,' which tells the agent the prerequisite workflow. While it does not explicitly exclude alternative tools or mention synced crypto variants, the guidance implies the correct usage scenario: retrieving a specific manual crypto entry after listing.

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

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

Annotations already declare readOnlyHint=true, indicating no side effects. The description adds no further behavioral traits, but it doesn't contradict. The description is adequate given the 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?

Single sentence, front-loaded, and no extraneous words. Every part contributes to understanding the tool's 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?

For a simple read tool with one parameter and annotations covering safety, the description is complete. It tells what it does and how to find the required ID.

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

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

Schema coverage is 100%, and the parameter description includes usage guidance ('Call get_all_plaid_accounts first'). The tool description does not add param details, but the schema already provides good semantics. Baseline of 3 plus extra for the hint.

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 details of a single Plaid (synced) account by ID.' It uses a specific verb 'Get', specifies the resource 'single Plaid account', and distinguishes from sibling tools like get_all_plaid_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 description implies usage when needing details for one account, and the parameter hint 'Call get_all_plaid_accounts first to discover ids' provides a prerequisite. It doesn't explicitly differentiate from other get_single_* tools, but 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?

The annotations already declare readOnlyHint=true, so the description does not need to repeat that. It adds value by explaining that the optional date range populates the 'matches' object, which is behavioral information beyond the annotations. No contradictions.

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 just two sentences. The first sentence delivers the core purpose, and the second provides key additional context (date range effect). Every word is functional with no waste.

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

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

Given the tool's simplicity (single retrieval with optional date range), the description is largely complete. It covers the core functionality and the optional parameter effect. However, there is no output schema, and the description does not detail the response structure beyond 'matches,' which could be a minor gap for agents needing to parse the result.

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

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

Schema coverage is 100%, so the schema already documents parameters well. The description adds context by stating that the date range populates the 'matches' object, linking the parameters to the functionality. This provides meaning beyond the schema's 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 'Retrieve a single recurring item by ID,' which is a specific verb and resource. It also mentions the optional date range for populating the matches object, adding clarity. The tool is distinct from its sibling 'get_recurring_items' which lists all items.

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

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

The description implies usage context by noting that the recurringId should be obtained from 'get_recurring_items' first. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide conditions for when not to use it. The guidance is minimal.

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

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

Annotations provide readOnlyHint=true, indicating a safe read. The description adds that the tool returns 'all its nested balances,' which informs the agent of the scope of the response. However, it doesn't describe error behavior or response format. Since annotations cover the safety profile, this is sufficient.

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 12-word sentence, front-loaded with the verb, and contains no filler. It is appropriately 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 get-by-ID tool with one parameter and readOnlyHint annotation, the description covers the core purpose and hints at return contents ('nested balances'). It doesn't specify return structure or error cases, but given the low complexity, it's fairly complete.

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

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

The schema already describes crypto_id at 100% coverage ('Id of the synced crypto account to retrieve'). The description merely says 'by ID' without adding any new information about the parameter, so it doesn't elevate beyond the schema baseline.

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

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

The description uses the specific verb 'Get,' identifies the resource as 'a single synced crypto account' and clarifies scope with 'all its nested balances by ID.' This distinguishes it from siblings like get_all_synced_crypto (plural) and get_single_manual_crypto (manual vs synced).

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 by stating 'by ID' and 'single synced crypto account,' indicating it's for retrieving one specific synced crypto account. However, it doesn't explicitly mention alternatives or when not to use it, such as using get_all_synced_crypto for listing or get_synced_crypto_balance for just balances.

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

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

Annotations already declare readOnlyHint=true, so the description adds no additional behavioral traits beyond confirming it's a retrieval operation. No contradiction.

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

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

The description is a single, front-loaded sentence 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 simple single-parameter read operation with good annotations, the description is adequate. It could mention the return value, but the tool is straightforward.

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 for the single parameter, and the schema description already explains the parameter well. The tool description adds no extra semantic value beyond the schema.

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

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

The description clearly states the action ('Get details'), the resource ('single tag'), and the identifier ('by ID'). It distinguishes from siblings like 'get_all_tags' and 'update_tag'.

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

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

The description implies usage when you have a tag ID, and the parameter description suggests calling 'get_all_tags' first, but there is no explicit statement of when to use or when not to use this tool vs alternatives.

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

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

Annotations already declare readOnlyHint=true, so the description's confirmation that this is a retrieval operation is consistent but adds no new behavioral traits. It does add value by listing the specific response fields, but beyond that, there is no disclosure of rate limits, auth needs, or other behaviors.

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 immediately conveys purpose and key differentiating information. No unnecessary words.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the essential aspects: purpose, unique response contents, and relationship to a sibling tool. It is complete for the agent's decision-making.

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% description coverage for the single parameter 'transaction_id'. The description does not add any additional meaning or context 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 that the tool retrieves details of a specific transaction, specifying the included fields (plaid_metadata, custom_metadata, files, and children for split/group parents). It distinguishes itself from the sibling get_transactions by noting these fields are not returned by default.

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 full details beyond get_transactions are needed) by contrasting its output. It does not explicitly state when not to use or mention alternatives, but 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?

With annotations providing readOnlyHint, the description adds value by specifying that the list is for manual tracking and that the symbols are prerequisites for create_manual_crypto. This clarifies the relationship to other tools and the nature of the data, going beyond the annotation without contradicting it.

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

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

The description is two sentences, front-loaded with the primary action, and the second sentence provides essential cross-tool context. No words are wasted, making it concise and well-structured.

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

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

For a simple zero-parameter tool with a readOnlyHint and no output schema, the description is complete: it explains what the tool returns (supported cryptocurrencies) and how the output should be used. No critical information is missing for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter information because none is needed; the empty schema fully covers the parameters, and the description's focus on the output symbol is more relevant.

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 the list of cryptocurrencies supported for manual tracking,' which specifies the verb (get), the resource (cryptocurrencies), and the scope (supported for manual tracking). It distinguishes from siblings like get_all_manual_crypto and add_supported_cryptocurrency by clarifying its role as the supported list, not the user's tracked list or the add operation.

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

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

The description gives clear guidance on when to use this tool: before calling create_manual_crypto, since the symbol must come from this list. It does not explicitly mention alternatives or exclusions, but the connection to create_manual_crypto provides strong contextual usage direction, so it earns a 4 rather than a 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?

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds scoping constraints ('single', 'by its cryptocurrency symbol') but does not disclose response format, error behavior, or case sensitivity beyond what annotations provide.

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

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

The description is one sentence of 13 words, front-loaded with the action verb. Every word contributes to meaning, with no filler or redundancy.

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

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

No output schema exists, so the description should clarify return value, but 'single balance' conveys the core concept. Combined with the readOnlyHint and simple two-parameter schema, the description is nearly complete; it only lacks explicit return format or not-found behavior, which are minor for a straightforward getter.

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 (crypto_id and symbol) described in the schema. The description's phrase 'looked up by its cryptocurrency symbol' reinforces the schema but adds no new semantic detail beyond what is already documented.

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' with a clear resource 'single balance' and scoping 'inside a synced crypto account, looked up by its cryptocurrency symbol.' It distinguishes itself from sibling tools like get_crypto_synced_balance_history and get_single_synced_crypto by focusing on a single balance lookup rather than history or account details.

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

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

The description implies when to use the tool (to fetch a single balance by symbol) but does not explicitly state alternatives or exclusions. There is no mention of when to prefer this over balance history or refresh_synced_crypto, leaving the agent to infer the intended context.

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

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

Annotations already indicate readOnlyHint=true, so the description correctly aligns with a read operation. It adds value by specifying the URL is 'short-lived' and includes an 'expires_at' timestamp, providing behavioral context beyond the annotation.

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

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

The description consists of two concise sentences. The first sentence states the action, and the second describes the response. No unnecessary words or repetition; every sentence earns its place.

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

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

For a simple retrieval tool with a single parameter and no output schema, the description adequately covers the response (URL and expires_at). It could optionally mention usage restrictions or typical timeout, but overall is complete enough.

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 one parameter ('file_id') having a clear description. The tool description does not add additional meaning beyond the schema, so it meets the baseline but does not provide extra semantic enrichment.

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 resource 'short-lived signed download URL for a transaction file attachment', making the tool's purpose specific and unambiguous. It distinguishes from siblings like attach_file_to_transaction and delete_transaction_attachment.

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, nor does it provide exclusions or prerequisites. Usage is implied by the function name and sibling context, but no direct guidance is offered.

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

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

Annotations already declare readOnlyHint=true. The description adds critical behavioral details: pagination behavior (limit, has_more, offset), default exclusions (pending, split-parents, group-children), and that include_* flags can override. No contradictions.

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: first lists filter options, second explains pagination and default exclusions. Efficient, front-loaded, 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 retrieval tool with 20 parameters and no output schema, the description covers pagination, default filters, and override flags. It could mention the response format (e.g., array of transaction objects) but is otherwise complete.

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

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

Schema coverage is 85%, so the schema already documents most parameters. The description summarizes filter types (e.g., 'date range, account, category, tag') but does not add meaningful details beyond what the schema descriptions provide, e.g., no explanation of the 'status' enum values.

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 'Retrieve transactions' and enumerates numerous filtering dimensions (date, account, category, etc.), distinguishing it from siblings like get_single_transaction or create_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 explains optional filters, default limit, and that pending/split-group exclusions apply by default. It does not explicitly contrast with sibling tools (e.g., get_single_transaction) but provides enough context for when to use 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?

The readOnlyHint annotation already indicates it's a safe read operation. The description adds no further behavioral details, but does not contradict the annotation. Given the annotation coverage, this is adequate.

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

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

The description is a single concise sentence that immediately conveys the tool's purpose 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?

Given no parameters and no output schema, the description fully explains what the tool does. The sibling tools list provides context, but the description itself is complete for its simplicity.

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

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

There are no parameters, so the schema provides complete coverage. The description adds no additional parameter info, but none is needed. Baseline for 0 params is 4.

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 details on the current user', which is a specific verb-resource combination. It distinguishes itself from sibling tools like get_budget_settings or get_transactions by explicitly targeting the current user.

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

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

The description implies usage context (retrieving current user details) but does not explicitly state when to use this tool over alternatives. Still, it is clear enough for an agent to infer its purpose.

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

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

The annotation openWorldHint already signals external side effects, and the description explicitly mentions reaching out to the external crypto provider, which adds behavioral context. It does not contradict the annotation. It lacks details on potential failure or latency, but given the tool's simplicity, the disclosure is sufficient.

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

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

The description is concise, with two clear sentences that front-load the primary action and immediately state the return value. 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 one-parameter tool without an output schema, the description covers the key aspects: what it does, what it returns, and that it makes an external call. It lacks any note on error conditions or timing, but these are not critical for the tool's basic usage.

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

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

The single parameter crypto_id is fully described in the schema ('Id of the synced crypto account to refresh'), and the description adds no further semantic meaning. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Trigger a balance refresh') and the resource ('a synced crypto account'), with the specific outcome of returning the refreshed account. This distinguishes it from sibling tools like get_synced_crypto_balance or get_single_synced_crypto, which do not perform a refresh.

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

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

The description provides clear context: it is used to refresh a synced crypto account via an external provider call. It implies when to use it (to get up-to-date balance) but does not explicitly exclude alternatives like reading a cached balance. However, the sibling name get_synced_crypto_balance suggests the alternative, so the guidance is adequate.

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

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

The description adds the key behavioral detail that the request is idempotent, which goes beyond the annotations' 'destructiveHint: true'. This informs the agent that calling it when no budget exists is harmless.

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

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

The description is short, with two sentences. The first sentence clearly states the purpose, and the second provides an important behavioral note. No unnecessary 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 destructive tool with two parameters, the description covers purpose and idempotency. It lacks details on return values or error handling, but given no output schema, this is sufficient context.

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

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

Schema description coverage is 100%, so the schema already documents the parameters adequately. The description does not add extra meaning beyond what the schema provides, leading to a baseline score of 3.

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

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

The description explicitly states the action ('remove'), the resource ('budget'), and the scope ('for a specific category and period'), clearly distinguishing it from sibling tools like 'upsert_budget' or 'get_budget_summary'.

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

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

The description mentions idempotency but does not provide explicit guidance on when to use this tool versus alternatives (e.g., 'upsert_budget'), nor does it specify prerequisites or scenarios where removal is inappropriate.

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 post-split behavior: parent is hidden and children are listed under it via get_single_transaction. It also states the sum constraint. Annotations only note non-idempotency, but description provides richer behavioral context beyond annotations.

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

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

Description is three sentences, each sentence adds essential information: action and range, constraint, and behavioral effect. No unnecessary words. Front-loads 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?

For a mutation tool with 2 required parameters and no output schema, the description explains the effect on parent and child relationship, and provides constraints. It does not describe the return value, but given the behavioral context, it is sufficiently complete for agent decision-making.

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?

Input schema has 100% coverage for parameter descriptions. The tool description adds the constraint that child count must be 2-500 and sum equals parent amount, but this is redundant with schema comments. No additional parameter semantics are provided beyond what schema already defines, so baseline of 3 applies.

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

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

The description clearly states the action 'Split an existing transaction into 2-500 child transactions' with a specific verb, resource, and range. It distinguishes from sibling tools like unsplit_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 explains the consequence of splitting (parent becomes hidden from get_transactions but accessible via get_single_transaction), providing clear when-to-use and behavioral outcomes. The presence of unsplit_transaction in siblings implies the reverse operation.

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

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

With only openWorldHint annotation, the description carries the burden: it discloses the rate limiting (60s delay) and long duration (up to 5 min), which are key behavioral traits beyond what annotations provide. No contradictions with annotations.

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

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

Two sentences, no wasted words: first sentence states the core action, second adds optional scoping and important constraints. Well front-loaded.

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

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

Given three optional parameters and no output schema, the description covers the essential: what it does, optional scoping, and performance constraints. Minor omission: no mention of what happens if rate limit is hit (e.g., error handling).

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 description adds little new meaning. It mentions scoping to date range and account ID, which paraphrases the schema. The mutual requirement of start_date and end_date is implied but not explicitly reinforced.

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 triggers a fetch of latest data from Plaid, with optional scoping to date range or specific account. This verb+resource combination is distinct from siblings which are mostly read or manage operations on existing data.

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 notes the 60-second delay and up to 5-minute fetch time, setting expectations. However, it does not explicitly contrast with alternative tools like get_all_plaid_accounts (which is read-only) or when not to use 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?

Beyond destructiveHint annotation, description explains specific destructive action (deleting children) and restoring parent.

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

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

Two sentences, no wasted words, front-loaded with purpose then usage.

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?

Fully explains behavior and parameter usage for a simple one-parameter tool.

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

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

Schema already has 100% coverage, and description reinforces how to find the correct ID, adding clarity.

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 it unsplits a transaction by deleting children and restoring the parent. It distinguishes itself from sibling tool split_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?

Provides explicit guidance on passing the parent ID, not a child. Lacks explicit alternatives but 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?

Beyond the idempotentHint annotation, the description discloses key behaviors: 'supplying children replaces the group's full child list' and 'Cannot be used to convert between category and category group.' This adds useful context for safe invocation.

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 every sentence adds value. No unnecessary 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 an update tool with 9 parameters and no output schema, the description covers the main constraints and behaviors. It lacks return value details but is otherwise complete for an update 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 description adds some value by explaining the children parameter behavior, but overall parameter semantics rely heavily on the input schema (56% coverage). The description does not compensate for undocumented parameters sufficiently.

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

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

The description clearly states the tool updates an existing category or category group, with a specific verb and resource. It distinguishes between updating a category and a category group, and among siblings like create_category and delete_category, its purpose is evident.

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

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

The description implies usage by stating what the tool does but does not explicitly guide when to use it over alternatives like create_category or delete_category. No exclusions or when-not-to-use guidance is provided.

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

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

Beyond the idempotentHint annotation, the description adds valuable behavioral context: the update applies to all historical entries for the deleted source, and passing null clears a field. It also implies the operation is non-destructive to the deleted account itself. No contradiction with annotations.

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

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

Two sentences, front-loaded with the main action, followed by scope and a usage rule. Every sentence is informative and there is no wasted wording.

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

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

For a simple update tool with 7 params (all but one optional) and no output schema, the description covers purpose, scope, and the null-clearing convention. It adequately addresses the required-field rule and the effect on historical entries, making it complete for an AI 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 each parameter having a description. The description adds a cross-cutting semantic: 'pass null to clear a field', which is not present in any individual parameter description. This extra meaning raises the score above the baseline of 3.

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

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

The description uses a specific verb ('Update') and resource ('display details for a deleted account') with scope ('in the Net Worth views'), clearly distinguishing it from sibling tools. It also clarifies it applies to all historical entries for that deleted source, leaving no ambiguity about what the tool does.

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

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

The description provides clear context for when to use the tool (for deleted accounts) and includes a key usage rule ('At least one field must be provided; pass null to clear a field'). However, it does not explicitly name alternatives or exclusion cases, so it falls short of a 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?

The description does not add behavioral context beyond the idempotentHint annotation. It does not disclose partial update behavior, error handling, or prerequisites. No contradiction with annotations, but no added value.

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 unnecessary words. The historical rename note is brief and informative. No fluff.

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 complexity (11 parameters, no output schema), the description is minimal. It does not explain return values, partial update behavior, or required fields beyond accountId. Many sibling tools exist, but no context is provided for selection.

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 9% (only accountId has a description). The tool description does not explain any parameters or their semantics. The description fails to 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 the verb 'Update' and the resource 'existing manually-managed account', and distinguishes from siblings like create_manual_account and delete_manual_account by specifying 'update' and 'manually-managed'. The former name note adds clarity.

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 updating manual accounts, but does not provide explicit when-to-use or when-not-to-use guidance, nor alternatives among the many sibling tools. There is no exclusion or context about when to prefer this over other update tools.

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

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

The annotation idempotentHint=true already conveys idempotency. The description adds useful constraints: 'At least one of... must be supplied' and 'The symbol... cannot be changed.' These are not in the annotations and add value. However, the description does not disclose other behaviors such as error handling or whether omitted fields retain their values, which leaves some 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 two sentences, each essential. It front-loads the purpose and immediately gives the critical 'at least one' requirement and the symbol immutability constraint. No word is wasted.

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

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

Given the tool's moderate complexity (5 params, 1 required, idempotentHint), the description covers the main purpose, the validation rule, and a key behavioral limitation. It doesn't mention that omitted fields remain unchanged, but the schema's null descriptions and partial-update phrasing imply it. With no output schema, this is adequate.

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

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

Schema coverage is 100% with detailed parameter descriptions, so baseline is 3. The description adds a crucial cross-parameter rule not in the schema: at least one of name, display_name, institution_name, or balance must be supplied. This goes beyond the schema's required crypto_id and clarifies validation logic.

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 'Update a manually-managed crypto balance,' which clearly identifies the action and resource. It distinguishes from sibling tools like create/delete/get manual crypto and from synced crypto tools. The added constraints about required fields and immutable symbol further clarify its role.

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 'manually-managed' sets a clear context for when to use this tool. It doesn't explicitly name alternatives or exclusions, but the resource type is unambiguous. The schema's crypto_id description also notes that synced crypto cannot be updated, reinforcing the manual-only scope.

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

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

Annotations provide idempotentHint=true, and the description states 'Update' which is consistent. No additional behavioral details are added (e.g., side effects, permissions), but annotations already cover the idempotency trait.

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 that directly communicates the tool's purpose. No unnecessary 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?

With 6 parameters, only 1 required, no output schema, and minimal parameter descriptions, the description is severely inadequate. It lacks details on return values, parameter behavior, and overall operational context.

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

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

Schema description coverage is only 17% (only tagId has a description). The tool description does not explain any parameter semantics beyond what the schema provides, failing to compensate for the low coverage.

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

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

The description 'Update properties for an existing tag' clearly states the action (updating) and the resource (tag), distinguishing it from create/delete/get operations. It could be more specific about which properties, but it's clear enough.

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

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

No guidance on when to use this tool versus alternatives like create_tag or delete_tag. The description does not mention any context for usage, leaving the agent to infer.

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

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

Annotations already indicate idempotency (idempotentHint: true). Description adds useful constraint about split/group transactions but no further behavioral traits (e.g., response format, error behavior). Adequate but not exceptional.

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

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

Two sentences, no fluff, front-loaded with the core action. Every word earns its place.

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

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

Given the tool's complexity (nested update object, high schema coverage but no output schema), the description covers the key constraint and API version change. Missing a note on return value, but output schema is absent, so minor gap.

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

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

Schema description coverage is 100%, so the description does not need to add much. It mentions 'writable fields' and the v2 envelope change, but does not explain individual parameters beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb (update) and resource (existing transaction), and distinguishes from siblings by explicitly mentioning that split or grouped transactions cannot be modified and should use corresponding tools.

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

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

Provides direct when-to-use and when-not-to-use guidance: cannot modify split/grouped transactions, and directs to use split/group tools instead. No ambiguity.

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