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

The description adds significant behavioral context beyond the readOnlyHint annotation. It discloses the API call cost structure (3 + C + M calls, plus additional calls if apply=true), explains the cascading effects across months, and clarifies the difference between audit-only mode and automatic correction mode. This provides valuable operational context that annotations don't cover.

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 efficiently structured with zero waste. The first sentence states the core purpose, the second explains the recommendation logic, and the third provides crucial cost information. Every sentence earns its place by adding distinct 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?

For a mutation tool with readOnlyHint=false but no output schema, the description does well by explaining the audit logic, cost implications, and the apply parameter's effect. It could be more complete by describing the return format or what happens when corrections are applied, but given the annotations and schema coverage, it provides substantial 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?

With 100% schema description coverage, the baseline is 3. The description adds some context about the 'apply' parameter (explaining it triggers automatic fixes and adds API calls), but doesn't provide additional semantic meaning for other parameters beyond what's already in the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Audits credit card payment categories by comparing each card's month-end balance against the payment category's available balance.' It specifies the verb (audits), resource (credit card payment categories), and method (balance comparison). It distinguishes from siblings by focusing on auditing rather than creating, updating, or listing operations.

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

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

The description provides explicit usage guidance: it explains when to use the tool (for auditing credit card payments), when not to use it (by default it's audit-only unless apply=true), and mentions the cost implications (API call counts). It also distinguishes from siblings by its specific auditing function versus general CRUD operations.

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

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

The annotation 'readOnlyHint: false' correctly indicates this is a write operation, which aligns with the 'Create' action. The description adds minimal behavioral context beyond this—it mentions '[1 API call]' which hints at performance/rate considerations, but doesn't cover permissions, error conditions, or what happens on success/failure.

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—just 7 words plus the API call notation. It's front-loaded with the core action and wastes no words. Every element serves a purpose: the bracket notation provides implementation context, and the rest states the essential operation.

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

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

For a creation tool with no output schema and minimal annotations, the description is adequate but incomplete. It covers the basic 'what' but lacks information about return values, error handling, or system behavior post-creation. Given the mutation nature and sibling tools, more context would be helpful.

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 100% schema description coverage, the input schema fully documents all parameters. The description adds no additional parameter semantics—it doesn't explain relationships between parameters, provide examples, or clarify edge cases beyond what's already in the schema descriptions.

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

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

The description clearly states the action ('Create a new account') and resource ('in a budget'), making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'list_accounts' or 'get_account' beyond the obvious creation vs. retrieval distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a budget first), when not to use it, or how it differs from other account-related tools like 'list_accounts' or 'get_account' beyond the basic create 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?

The annotation 'readOnlyHint: false' correctly indicates this is a write operation, which aligns with the 'Create' action in the description. The description adds minimal behavioral context by specifying '[1 API call]', which hints at performance characteristics, but doesn't elaborate on permissions, side effects, or error conditions that would be valuable for a creation tool.

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

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

The description is extremely concise—just one sentence plus an API call notation—with zero wasted words. It's front-loaded with the core purpose, making it easy for an agent to parse quickly and efficiently.

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

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

For a creation tool with no output schema and minimal annotations, the description is adequate but lacks depth. It covers the basic purpose and hints at API usage, but doesn't address what happens after creation (e.g., response format, error handling, or how it integrates with sibling tools like 'list_categories'), leaving gaps in contextual understanding.

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 100% schema description coverage, all parameters are well-documented in the input schema itself. The description doesn't add any additional semantic context about the parameters beyond what's already in the schema, so it meets the baseline expectation without enhancing 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 a new category') and resource ('in a budget'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'create_category_group' or 'update_category', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_category_group' or 'update_category'. It also doesn't mention prerequisites or constraints beyond what's implied by the parameters, leaving the agent without contextual usage 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?

The annotation 'readOnlyHint: false' already indicates this is a write operation, which the description confirms with 'Create'. The description adds minimal behavioral context with '[1 API call]', hinting at a single network request, but doesn't disclose permissions, side effects, error conditions, or response format. It doesn't contradict annotations but adds limited value beyond 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 extremely concise—two brief phrases with zero wasted words. It front-loads the key information ('Create a new category group') and includes a useful technical note ('[1 API call]'). Every element serves a purpose without redundancy.

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

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

For a creation tool with no output schema and minimal annotations, the description is incomplete. It lacks details on what the tool returns (e.g., the created category group object), error handling, or dependencies. However, the simple parameter set (2 params) and clear purpose partially compensate, making it minimally viable but with 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?

With 100% schema description coverage, the input schema fully documents both parameters (budget_id and name). The description adds no parameter-specific information beyond what's in the schema, such as examples or constraints. The baseline score of 3 reflects adequate coverage via 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 specific action ('Create a new category group') and specifies the resource context ('in a budget'), which distinguishes it from sibling tools like 'create_category' or 'update_category_group'. It uses a precise verb+resource combination that leaves no ambiguity about the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_category_group' or 'merge_category'. It doesn't mention prerequisites (e.g., needing an existing budget), exclusions, or typical use cases. The agent must infer usage from the tool 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 indicate readOnlyHint=false, confirming this is a write operation, which aligns with 'Create' in the description. The description adds useful context about the date constraint (future, up to 5 years) and mentions '[1 API call]', hinting at performance. However, it lacks details on permissions, error handling, or what happens on creation (e.g., returns an ID), leaving behavioral gaps.

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

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

The description is two short sentences with zero waste: the first sentence states the purpose and key constraint, and the second adds the date limit. It is front-loaded with essential information and appropriately sized for the tool's complexity.

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 (10 parameters, write operation) and lack of output schema, the description is somewhat incomplete. It covers the purpose and date constraints but misses details on return values, error cases, or dependencies (e.g., budget/account existence). With annotations providing only readOnlyHint, more behavioral context would improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents all 10 parameters. The description does not add any parameter-specific semantics beyond what's in the schema (e.g., it doesn't explain parameter interactions or provide examples). This meets the baseline 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 clearly states the verb ('Create') and resource ('new scheduled (recurring) transaction'), specifying it's for recurring transactions. It distinguishes from sibling 'create_transaction' by emphasizing the scheduled/recurring nature, making the purpose specific and differentiated.

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

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

The description provides clear context for when to use this tool (for future-dated recurring transactions) with the date constraint 'must be in the future (up to 5 years)'. However, it does not explicitly mention when not to use it or name alternatives like 'create_transaction' for one-time transactions, though the context is 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 description adds useful behavioral context beyond the annotations: it clarifies that amounts are in dollars with positive/negative conventions, explains how split transactions work, and mentions '[1 API call]' which suggests a single operation. The annotations only indicate readOnlyHint=false (implying mutation), so the description provides additional implementation details without contradicting the annotations.

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

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

The description is extremely concise (three sentences) with zero wasted words. It front-loads the core purpose, then provides essential behavioral context, and finally gives specific usage guidance for split transactions. Every sentence earns its place by adding distinct 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?

For a mutation tool with no output schema, the description provides good context about the operation's behavior (dollar amounts, split transactions, API call count). However, it doesn't mention potential side effects, error conditions, or what happens when payee_name creates a new payee. Given the complexity of 12 parameters and mutation nature, some additional context would be helpful.

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 100% schema description coverage, the input schema already documents all 12 parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it clarifies the dollar unit and sign convention for 'amount', and explains the relationship between 'category_id' and 'subtransactions' for splits. This meets the baseline 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 clearly states the specific action ('Create a new transaction') and resource ('transaction'), distinguishing it from sibling tools like 'create_transactions' (plural) or 'update_transaction'. It provides essential context about amounts in dollars with sign conventions, making the purpose unambiguous.

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

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

The description provides clear guidance on when to use this tool for split transactions ('set category_id to null and provide subtransactions'), which helps differentiate from non-split scenarios. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the many sibling tools (e.g., vs 'create_transactions' or 'import_transactions').

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

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

The annotation (readOnlyHint: false) already indicates this is a write operation. The description adds useful context about it being a 'bulk' operation and '[1 API call]', which helps the agent understand efficiency implications. However, it doesn't disclose other behavioral traits like error handling for partial failures, rate limits, or authentication requirements 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 extremely concise (two sentences) and front-loaded with the core purpose. Every word earns its place: the first sentence establishes the bulk operation and API efficiency, while the second clarifies minimum requirements. No wasted words or 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?

For a write operation with no output schema, the description adequately covers the core functionality and minimum requirements. However, it could better address the complexity of bulk operations by mentioning potential error scenarios or response format expectations. The 100% schema coverage helps compensate, but behavioral context for a mutation tool remains somewhat light.

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 100% schema description coverage, the schema fully documents all parameters. The description adds minimal value by mentioning that 'Each transaction needs account_id, date, and amount at minimum,' which reinforces the required fields but doesn't provide additional semantic context beyond what's already in the schema's required array and property descriptions.

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

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

The description clearly states the specific action ('Create multiple transactions at once'), identifies the resource ('transactions'), and distinguishes it from the sibling 'create_transaction' tool through the explicit 'bulk' operation and 'multiple' qualifier.

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

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

The description provides clear context for when to use this tool ('bulk' creation of multiple transactions) and implicitly suggests an alternative (the sibling 'create_transaction' for single transactions). However, it doesn't explicitly state when NOT to use it or compare it directly with other transaction-related tools like 'import_transactions'.

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

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

Annotations already indicate this is a destructive, non-read-only operation, so the description doesn't need to repeat that. It adds minimal context with '[1 API call]' hinting at network cost, but fails to disclose critical behavioral traits like whether deletion is permanent, if it affects related data, or what happens on success/failure.

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 with a bracketed note) and front-loaded with the core action. Every element earns its place: the API call hint sets expectations, and the main clause states the purpose without 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 destructive tool with no output schema, the description is inadequate. It doesn't explain what happens post-deletion (e.g., confirmation, error handling, or side effects) or tie into the broader context of sibling tools. Given the complexity of financial data mutation, more completeness is needed.

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 100% schema description coverage, the schema fully documents both parameters. The description adds no parameter semantics beyond what's in the schema (e.g., explaining ID format or 'last-used' implications), so it meets the baseline of 3 without providing extra value.

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

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

The description clearly states the verb ('Delete') and resource ('a scheduled transaction'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'delete_transaction' or 'update_scheduled_transaction', which would require explicit comparison to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'delete_transaction' or 'update_scheduled_transaction' (which might disable instead of delete). It also lacks prerequisites (e.g., needing the transaction ID from 'get_scheduled_transaction') or warnings about irreversible deletion.

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

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

Annotations already indicate this is a destructive, non-read-only operation. The description adds minimal context with '[1 API call]', hinting at a single network request, but does not disclose further behavioral traits like error handling, permissions required, or irreversible effects 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 extremely concise with two short phrases, front-loading the key action ('Delete a transaction') and adding a minor operational note ('[1 API call]'). Every word serves a purpose, with no wasted text.

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 destructive nature and lack of output schema, the description is minimally complete but lacks depth. It covers the basic action and API call count, but does not address potential outcomes, error scenarios, or confirmation needs, leaving gaps for an agent to infer behavior.

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

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

Schema description coverage is 100%, fully documenting both parameters. The description does not add any semantic details beyond the schema, such as explaining the implications of 'budget_id' defaulting to 'last-used'. Baseline score of 3 applies as the schema handles parameter documentation adequately.

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

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

The description clearly states the action ('Delete') and resource ('a transaction'), making the purpose unambiguous. However, it does not differentiate this tool from sibling tools like 'delete_scheduled_transaction' or other deletion operations, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., 'delete_scheduled_transaction' or other transaction-related tools). It lacks context about prerequisites, such as needing a valid transaction ID, or exclusions, leaving the agent without usage direction.

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

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

Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by specifying '[1 API call]', which hints at performance or rate limit considerations not covered by annotations. However, it lacks details on error handling, response format, or other behavioral traits like pagination or authentication needs.

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 only one sentence, front-loaded with the key information (API call count and purpose). There's no wasted verbiage, and it efficiently communicates the core functionality without unnecessary elaboration.

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 (2 parameters, read-only, no output schema), the description is minimally adequate. It covers the basic action and API call count but lacks context on output structure, error cases, or integration with sibling tools. With annotations providing safety info, it's complete enough for a straightforward read operation but could be more informative.

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

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

Schema description coverage is 100%, with clear documentation for both parameters (budget_id and account_id). The description doesn't add any semantic details beyond what's in the schema, such as explaining the significance of 'last-used' for budget_id or how account_id is sourced. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the verb ('Get') and resource ('details for a single account'), making the purpose specific. However, it doesn't distinguish this tool from sibling tools like 'list_accounts' or 'get_user', which could also retrieve account-related information, leaving some ambiguity about when to use this specific 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'list_accounts' (for multiple accounts) and 'get_user' (possibly for user account details), there's no indication of context, prerequisites, or exclusions, leaving the agent to infer usage based on tool names alone.

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

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

The annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds valuable behavioral context about rate limit checking (200 calls/hour) and the practical use case for batch operations, which goes beyond what annotations provide. It doesn't contradict 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 perfectly concise with two sentences that each earn their place: the first states the core functionality, the second provides usage guidance. It's front-loaded with the essential purpose and wastes no 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-parameter read-only tool with annotations covering safety, the description provides excellent context about rate limits and batch operation use cases. The only minor gap is the lack of output schema, but the description adequately explains what information will be returned (API usage against rate limit).

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 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since there are none, and the schema already fully documents the empty input object.

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

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

The description clearly states the specific action ('Check current YNAB API usage') and resource ('against the 200 calls/hour rate limit'), distinguishing it from all sibling tools which focus on budget data management rather than API monitoring. It provides a complete, unambiguous purpose statement.

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

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

The description explicitly states when to use this tool ('before batch operations to ensure you have enough budget'), providing clear contextual guidance. It doesn't need to mention alternatives since no sibling tools serve a similar API monitoring function.

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 valuable behavioral context beyond the readOnlyHint annotation by specifying '[1 API call]' which indicates resource usage/rate limit implications, and explains the special 'last-used' parameter behavior. While it doesn't describe return format or pagination, it provides useful operational context that annotations don't cover.

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 perfectly concise with two sentences that each earn their place: the first establishes the core functionality and API cost, the second provides critical usage guidance. No wasted words, front-loaded with essential information.

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

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

For a read-only tool with good annotations and full schema coverage, the description provides adequate context about what the tool returns ('full detail including all entities') and operational considerations. The main gap is lack of output format details, but given the readOnlyHint annotation and clear purpose, this is reasonably complete.

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

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

With 100% schema description coverage, the baseline would be 3, but the description adds meaningful context about the 'last-used' parameter that enhances understanding beyond the schema's technical description. It explains the practical meaning and use case for this special value, which adds semantic value.

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

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

The description clearly states the specific action ('Get'), resource ('a single budget's full detail'), and scope ('including all entities'), distinguishing it from sibling tools like 'list_budgets' which would return multiple budgets. It provides a complete picture of what the tool does beyond just the name/title.

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

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

The description explicitly provides usage guidance by stating 'Use 'last-used' for the most recently accessed budget,' which tells the agent when to use this specific parameter value. It also implicitly distinguishes from 'list_budgets' by focusing on single budget retrieval rather than listing multiple budgets.

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 by specifying '[1 API call]', which indicates a single request without pagination or batching, and clarifies the scope ('date and currency format settings'). The annotations already declare readOnlyHint=true, so the agent knows it's safe, but the description provides additional behavioral context without contradicting annotations.

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

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

The description is a single, efficient sentence that front-loads key information (API call count and resource). There is no wasted text, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's simplicity (1 parameter, read-only, no output schema), the description is adequate but minimal. It covers the basic purpose and behavior but lacks details on output format or error handling, which could be useful for an agent despite the annotations providing safety 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?

The input schema has 100% description coverage, with the 'budget_id' parameter well-documented. The description does not add any parameter-specific information beyond what the schema provides, such as examples or constraints, so it meets the baseline 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 clearly states the action ('Get') and the resource ('a budget's date and currency format settings'), making the purpose specific. However, it does not explicitly distinguish this tool from sibling tools like 'get_budget' or 'list_budgets', which might retrieve different budget-related data, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'get_budget' or 'list_budgets', nor does it specify any prerequisites or exclusions for usage, leaving the agent without context for 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 adds the constraint '[1 API call]' which provides useful context about efficiency/rate limits beyond the readOnlyHint annotation. However, it doesn't describe other behavioral aspects like error conditions, response format, or whether it returns nested data. With annotations covering safety, this adds some value but not rich 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 extremely concise (one sentence plus API call note) with zero wasted words. It's front-loaded with the core purpose and efficiently includes the API call constraint without unnecessary elaboration.

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

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

For a read-only tool with good annotations and full schema coverage, the description is minimally adequate. However, without an output schema, it should ideally describe what 'details' include or the response structure. The API call note helps but doesn't fully compensate for missing output information.

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 fully documents both parameters (budget_id and category_id). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline 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 clearly states the tool's purpose with a specific verb ('Get details') and resource ('a single category'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_categories' or 'get_month_category', which would have required a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_categories' (for multiple categories) or 'get_month_category' (for category data in a specific month). It mentions '[1 API call]' which hints at efficiency but doesn't clarify usage context or prerequisites.

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

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

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds value by specifying '[1 API call]' (implying a single request without pagination) and clarifying that it returns 'detailed info... including all category balances,' which provides context beyond the annotation. However, it doesn't disclose other behavioral traits like error conditions, rate limits, or authentication needs, keeping the score at a baseline level.

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 highly concise and front-loaded, consisting of two sentences that efficiently convey key information: the API call count and the tool's purpose with a usage tip. Every sentence earns its place without redundancy or unnecessary details, making it easy to parse and understand quickly.

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

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

Given the tool's moderate complexity (2 parameters, read-only operation), the description is reasonably complete. It covers the purpose, API call count, and a usage tip. However, with no output schema, it doesn't describe the return format (e.g., structure of 'detailed info'), which could be helpful for an agent. The annotations provide safety context, but the description could add more about response behavior to achieve a score of 5.

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

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

Schema description coverage is 100%, with both parameters ('budget_id' and 'month') well-documented in the schema. The description adds minimal semantics by mentioning 'Use 'current' for the current month,' which slightly elaborates on the 'month' parameter but doesn't provide significant additional meaning beyond what the schema already covers. This meets the baseline score of 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 clearly states the tool's purpose: 'Get detailed info for a single budget month including all category balances.' It specifies the verb ('Get'), resource ('budget month'), and scope ('detailed info... including all category balances'). However, it doesn't explicitly differentiate from sibling tools like 'get_month_category' or 'list_months', which prevents a score of 5.

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

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

The description provides some usage guidance by mentioning 'Use 'current' for the current month,' which implies a common use case. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_month_category' for specific category details or 'list_months' for multiple months, nor does it mention prerequisites or exclusions. This leaves usage context implied rather than explicit.

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

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

The description adds '[1 API call]' which hints at performance/rate limit considerations, useful context beyond the readOnlyHint annotation. However, it doesn't disclose other behavioral traits like error handling, response format, or data freshness. With annotations covering safety (read-only), the description provides some added value but not comprehensive behavioral insight.

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

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

The description is a single, efficient sentence that front-loads key information (API call count and core purpose). It avoids redundancy but could be slightly more structured (e.g., separating behavioral notes from 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?

Given the tool's moderate complexity (3 parameters, read-only, no output schema), the description is minimally adequate. It states the purpose and hints at behavior but lacks details on output format, error cases, or integration with sibling tools. With annotations covering safety, it meets basic needs but leaves gaps for an agent to infer.

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 parameters are fully documented in the schema. The description doesn't add any meaning beyond the schema (e.g., it doesn't explain interactions between parameters or special cases). Baseline 3 is appropriate when the schema handles all parameter documentation.

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

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

The description clearly states the action ('Get') and resource ('a category's budget details for a specific month'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_category' or 'get_month', which provide similar category or month-level data, leaving some ambiguity about when to choose this specific 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 provides no guidance on when to use this tool versus alternatives like 'get_category' (for general category info) or 'get_month' (for month-level overview). It mentions the scope ('for a specific month') but lacks explicit comparisons or prerequisites, leaving the agent to infer usage from context 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?

The description adds minimal behavioral context beyond annotations: it specifies '[1 API call]', which hints at performance or rate limits, but annotations already declare readOnlyHint=true, covering safety. No details on response format, pagination, or error handling are provided, so it adds some value but not rich behavioral insight.

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 a single sentence that front-loads key information ('[1 API call]' and the action). There is no wasted text, making it efficient and easy to parse.

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

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

Given the tool's complexity (read-only with 2 parameters) and annotations covering safety, the description is minimally adequate. However, without an output schema, it fails to explain return values or data structure, leaving gaps in understanding what 'money movement groups' entail, which reduces completeness.

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

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

Schema description coverage is 100%, so the input schema fully documents both parameters. The description does not add any semantic details beyond what the schema provides, such as explaining 'money movement groups' or parameter interactions. Baseline 3 is appropriate as the schema handles the heavy lifting.

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

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

The description clearly states the action ('Get') and resource ('money movement groups for a specific month'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get_month_money_movements' or 'list_money_movement_groups', which appear to be related, so it misses full distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as sibling tools like 'get_month_money_movements' or 'list_money_movement_groups'. It lacks context on prerequisites, exclusions, or specific use cases, offering only basic functional information.

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 this is a safe read operation. The description adds minimal behavioral context with '[1 API call]' suggesting efficiency, but doesn't disclose details like pagination, rate limits, or error handling. No contradiction with annotations exists.

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 only one sentence, front-loaded with the key action and resource. There's no wasted text, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (2 parameters, read-only operation), the description is minimal but adequate when combined with annotations and schema. However, without an output schema, it doesn't explain return values like the structure of 'money movements', leaving some gaps in completeness.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (budget_id and month). The description adds no additional parameter semantics beyond what's in the schema, such as explaining 'money movements' or clarifying date handling. Baseline 3 is appropriate given 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 clearly states the action ('Get money movements') and resource ('for a specific month'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_money_movements' or 'get_month_money_movement_groups', which would require more specificity about scope or format.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_money_movements' or 'get_month_money_movement_groups'. It mentions '[1 API call]' which hints at efficiency but doesn't explicitly compare to siblings or define 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?

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds minimal behavioral context with '[1 API call]', hinting at cost or efficiency, but doesn't disclose other traits like rate limits, error handling, or authentication needs. No contradiction with annotations exists.

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 short phrases, front-loaded with the API call hint and core purpose. Every word earns its place, and there's no redundancy or unnecessary elaboration.

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

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

Given the tool's low complexity (simple read operation), 100% schema coverage, and read-only annotation, the description is minimally adequate. However, with no output schema, it doesn't explain return values (e.g., what details are included), leaving a gap in completeness for agent usage.

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

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

Schema description coverage is 100%, so the input schema fully documents both parameters (budget_id and payee_id). The description adds no additional meaning about parameters beyond implying a single payee is targeted, which is already clear from the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get details') and resource ('for a single payee'), making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'list_payees' or 'get_payee_location', which would require explicit comparison to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_payees' or 'get_payee_locations_for_payee'. It lacks context about prerequisites (e.g., needing a payee_id) or exclusions, leaving the agent to infer usage from the tool 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?

The annotation 'readOnlyHint: true' already indicates this is a safe read operation, so the description doesn't need to repeat that. The description adds minimal behavioral context by specifying '[1 API call]', which hints at performance, but it doesn't disclose other traits like error handling, rate limits, or what happens if the ID is invalid. No contradiction with annotations exists.

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—just one sentence with a bracketed note—and front-loaded with the core action. Every word serves a purpose, with no wasted information, making it easy to parse quickly.

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

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

Given the simple read operation with annotations covering safety and full schema coverage, the description is minimally adequate. However, without an output schema, it doesn't explain return values or potential errors, leaving gaps in understanding the tool's full behavior for an AI 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 100% schema description coverage, the input schema fully documents both parameters ('budget_id' and 'payee_location_id'), including defaults and requirements. The description adds no additional meaning beyond implying the tool uses 'payee_location_id' to fetch a single location, which is already clear from 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') and resource ('a single payee location by ID'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_payee_locations_for_payee' or 'list_payee_locations' beyond the 'single by ID' aspect, which is why it doesn't reach a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_payee_locations_for_payee' or 'list_payee_locations'. It lacks context about prerequisites, such as needing a payee location ID, and doesn't mention any exclusions or specific scenarios for its 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 annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds the constraint '[1 API call]', which hints at rate limit considerations, but doesn't elaborate on pagination, error conditions, or data format. It provides some context beyond annotations but lacks depth.

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

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

The description is a single, efficient sentence with zero waste. It front-loads key information (API call count and action) and avoids redundancy, making it highly 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?

Given the tool's simplicity (read-only, two parameters, no output schema), the description is adequate but minimal. It covers the basic action and scope but lacks details on output format, error handling, or sibling tool differentiation, leaving some contextual 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?

With 100% schema description coverage, the input schema fully documents both parameters (budget_id and payee_id). The description mentions 'a specific payee', aligning with payee_id, but adds no extra semantic detail beyond what the schema provides, meeting the baseline for high 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 action ('Get all GPS locations') and target resource ('for a specific payee'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'get_payee_location' (singular) or 'list_payee_locations', leaving some ambiguity about scope distinctions.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_payee_location' or 'list_payee_locations'. It lacks context about prerequisites (e.g., needing a payee_id) or exclusions, offering minimal usage direction.

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

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

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds minimal context with '[1 API call]', which hints at performance but doesn't elaborate on rate limits, authentication needs, or what 'details' include. It doesn't contradict 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 just one sentence, front-loaded with the key information. Every word earns its place, and there's no wasted text or redundancy.

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

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

Given the tool's low complexity (simple read operation), high schema coverage, and annotations covering safety, the description is minimally adequate. However, without an output schema, it doesn't explain what 'details' are returned, leaving a gap in completeness.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description doesn't add any meaning beyond the schema, such as explaining the significance of 'budget_id' or 'scheduled_transaction_id'. Baseline 3 is appropriate when schema handles parameter documentation.

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

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

The description clearly states the action ('Get details') and resource ('for a single scheduled transaction'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_transaction' or 'list_scheduled_transactions', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_transaction' or 'list_scheduled_transactions'. It mentions it's for a 'single' scheduled transaction, but doesn't clarify prerequisites 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?

The description adds the '[1 API call]' detail, which is useful context beyond the readOnlyHint annotation (which already indicates it's a safe read operation). However, it doesn't disclose other behavioral traits like error handling, response format, or any rate limits, leaving gaps in understanding how the tool behaves in practice.

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—just one sentence with a bracketed note—and front-loaded with the core purpose. Every word earns its place, making it easy to parse without unnecessary elaboration.

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

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

Given the tool's low complexity (a simple read operation), high schema coverage, and readOnlyHint annotation, the description is minimally adequate. However, without an output schema, it doesn't explain what details are returned (e.g., transaction fields), which could hinder the agent's ability to use the results effectively.

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

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

With 100% schema description coverage, the input schema fully documents both parameters (budget_id and transaction_id), including defaults and requirements. The description adds no additional parameter semantics, so it meets the baseline of 3 by not detracting from the schema's completeness.

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

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

The description clearly states the action ('Get details') and resource ('single transaction'), making the purpose understandable. However, it doesn't differentiate this tool from similar siblings like 'list_transactions' or 'get_account', which also retrieve data but for different resources or scopes.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'list_transactions' (for multiple transactions) and 'get_account' (for account details), it's unclear when this specific single-transaction retrieval is preferred, leaving the agent to guess based on 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 this retrieves 'the authenticated user's information,' which clarifies scope beyond the read-only annotation. However, it lacks details on response format, error conditions, or rate limits, leaving behavioral gaps despite the annotation covering safety.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads key information ('Get the authenticated user's information') and includes a useful detail ('including user ID') without unnecessary elaboration.

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 operation with annotations and no parameters, the description is adequate but minimal. It lacks output details (no schema provided) and doesn't fully address usage context, making it functional but not comprehensive.

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

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

With 0 parameters and 100% schema coverage, no parameter details are needed. The description appropriately omits parameter information, focusing on the tool's purpose without redundancy.

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

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

The description clearly states the action ('Get') and resource ('authenticated user's information including user ID'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_account' or 'get_payee', which also retrieve specific entity information.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication context) or compare it to similar sibling tools like 'get_account' for retrieving other entity types.

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 indicate readOnlyHint=false, consistent with the 'trigger' action implying a write operation. The description adds useful context by specifying '[1 API call]' (implying a single operation) and that it imports from 'linked financial institutions', which aren't covered by annotations. However, it lacks details on side effects (e.g., data overwriting), authentication needs, or rate limits.

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—a single sentence with no wasted words. It's front-loaded with the key action and resource, and the bracketed '[1 API call]' efficiently conveys operational context without verbosity.

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

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

Given the tool's complexity (a write operation with no output schema), the description is minimally adequate. It covers the core action and source but lacks details on outcomes (e.g., what happens after triggering), error handling, or integration with sibling tools. With annotations providing only readOnlyHint, more behavioral context would improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents the single parameter 'budget_id'. The description adds no additional parameter information beyond what's in the schema, such as explaining why a budget ID is needed or how 'last-used' works. This meets the baseline 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 clearly states the action ('Trigger an import') and resource ('transactions from linked financial institutions'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_transactions' or 'list_transactions', which handle different aspects of transaction management.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing linked institutions), timing considerations, or how it relates to sibling tools like 'create_transactions' for manual entry or 'list_transactions' for viewing imported data.

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 indicates this is a safe read operation. The description adds useful context about the API call count ('[1 API call]') and what data is returned ('balances and types'), but doesn't disclose other behavioral aspects like pagination, rate limits, or authentication requirements. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads key information (API call count, action, resource, and included data). Every element serves a purpose with zero waste, making it easy to parse quickly.

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

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

For a read-only list tool with good annotations and full parameter documentation, the description provides adequate context by specifying the scope ('for a budget') and return data ('balances and types'). However, without an output schema, it could benefit from more detail on the response structure or pagination behavior to be 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?

With 100% schema description coverage, the input schema fully documents both parameters ('budget_id' and 'last_knowledge_of_server'). The description doesn't add any parameter-specific semantics beyond what's in the schema, such as explaining the delta token usage or budget ID defaults. The baseline score of 3 is appropriate when the schema handles parameter documentation.

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

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

The description clearly states the action ('List all accounts') and resource ('for a budget'), and specifies what information is included ('balances and types'). However, it doesn't explicitly differentiate from sibling tools like 'get_account' (which retrieves a single account) or 'list_account_transactions' (which lists transactions for an 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 implies usage context by mentioning 'for a budget' and the API call count, but doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_account' (for single account details) or 'list_account_transactions' (for account-specific transactions). No exclusions or prerequisites are mentioned.

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

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

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds minimal context with '[1 API call]', hinting at performance or rate limits, but does not elaborate on pagination, return format, or other behavioral traits. It does not contradict 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 short phrases, front-loaded with the key action and resource. There is no wasted verbiage, making it efficient and easy to parse.

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

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

Given the read-only annotation and full schema coverage, the description is minimally adequate. However, without an output schema, it does not explain return values or format, and it lacks usage differentiation from siblings, leaving gaps in context for an AI agent.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description mentions 'specific account' and 'list transactions', which aligns with the schema but adds no additional meaning beyond it. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('transactions for a specific account'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'list_transactions' or 'list_accounts', which could cause confusion about 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?

The description provides no guidance on when to use this tool versus alternatives such as 'list_transactions' (which might list all transactions) or 'list_account_transactions' (which filters by account). It lacks explicit when/when-not instructions or named alternatives.

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

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

Annotations provide readOnlyHint=true, which the description doesn't contradict. The description adds valuable context: it discloses the API call cost ('[1 API call]'), which isn't covered by annotations, and hints at access control ('user has access to'). However, it doesn't mention pagination, rate limits, or response format details.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with key information (API call cost and core purpose) and uses clear, direct language. 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 low complexity (one optional parameter), high schema coverage, and read-only annotation, the description is mostly complete. It adds API call cost and access context. However, without an output schema, it doesn't describe the return format (e.g., list structure, fields), leaving a minor gap for a list tool.

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

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

Schema description coverage is 100%, so the schema fully documents the 'include_accounts' parameter. The description adds marginal value by mentioning 'optional account info', which aligns with the parameter but doesn't provide additional semantics beyond what's 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 clearly states the verb 'List' and resource 'budgets', specifies scope 'all budgets the user has access to', and distinguishes from siblings like 'get_budget' (singular) by indicating it returns multiple budgets. It's specific and differentiated.

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

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

The description implies usage for retrieving budgets, but doesn't explicitly state when to use this vs. alternatives like 'get_budget' (for a single budget) or other list tools. No exclusions or prerequisites are mentioned, leaving usage context somewhat implied rather than explicit.

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

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

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds value by specifying '[1 API call]', which informs about potential rate limits or performance, and clarifies that categories are 'grouped by category group', providing context beyond the annotations. However, it lacks details on pagination, error handling, or response format, which would enhance transparency further.

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 and front-loaded, consisting of a single sentence that efficiently conveys the core functionality and key behavioral note ('[1 API call]'). There is no wasted verbiage, and every element serves a clear purpose, making it easy for an agent to parse quickly.

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

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

Given the tool's low complexity (read-only, 2 parameters with full schema coverage, no output schema), the description is somewhat complete but has gaps. It covers the basic operation and a behavioral note, but lacks details on output structure, error cases, or sibling differentiation, which could help the agent use it more effectively in context with other tools.

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

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

Schema description coverage is 100%, so the input schema fully documents both parameters ('budget_id' and 'last_knowledge_of_server'). The description does not add any additional meaning or examples for these parameters, such as explaining the 'last-used' default or the purpose of the delta token. Thus, it meets the baseline but does not compensate with extra insights.

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

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

The description clearly states the verb ('List') and resource ('categories grouped by category group for a budget'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'list_category_transactions' or 'get_category', which also involve categories, leaving some ambiguity about when to choose this tool over those alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_category' for a single category or 'list_category_transactions' for transactions within categories. It mentions a budget context but does not specify prerequisites or exclusions, leaving the agent to infer usage from the tool 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?

The annotation already declares readOnlyHint=true, so the agent knows this is a safe read operation. The description adds the '[1 API call]' context, which provides useful implementation detail about cost/performance. However, it doesn't describe pagination behavior, rate limits, or response format, leaving gaps in behavioral understanding.

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 - just one sentence plus the API call notation. Every word serves a purpose, and the information is front-loaded with no unnecessary elaboration. This is an excellent example of efficiency in tool documentation.

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

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

For a read-only list operation with full schema documentation, the description provides adequate but minimal context. The API call notation is helpful, but without an output schema, the description doesn't explain what the returned transactions look like or how results are structured. Given the tool's relative simplicity, this is acceptable but not comprehensive.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema itself. The description doesn't add any parameter-specific context beyond what's already in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('List transactions') and target resource ('for a specific category'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'list_transactions' or 'list_account_transactions', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_transactions' (general listing) or 'list_account_transactions' (account-specific). There's no mention of prerequisites, constraints, or typical use cases beyond the basic functionality.

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 indicate readOnlyHint=true, which the description does not contradict. The description adds minimal behavioral context by specifying '[1 API call]', hinting at a single request without pagination or rate limits, but it lacks details on output format, error handling, or other operational traits beyond the annotations.

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

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

The description is extremely concise with two short phrases, front-loaded with the API call count and purpose. Every word contributes directly to the tool's functionality without unnecessary elaboration, making it efficient 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?

Given the simple input schema with one parameter and readOnlyHint annotation, the description is minimally adequate but lacks output details (no output schema provided) and deeper context like pagination or filtering options. It covers the basic purpose but could be more complete for a list 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?

With 100% schema description coverage for the single parameter 'budget_id', the schema already fully documents it. The description does not add any extra meaning or clarification about the parameter, such as examples or constraints beyond the schema, so it meets the baseline 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 clearly states the action ('List all') and resource ('money movement groups for a budget'), providing a specific verb+resource combination. However, it does not explicitly distinguish this tool from sibling tools like 'list_money_movements' or 'get_month_money_movement_groups', which might have overlapping functionality, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'list_money_movements' or 'get_month_money_movement_groups'. It mentions the budget context but does not specify prerequisites, exclusions, or comparisons to other tools, leaving usage unclear.

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 '[1 API call]' as context, which is useful behavioral information not covered by the annotations (which only indicate readOnlyHint=true). However, it doesn't disclose other traits like rate limits, pagination, error handling, or what 'all money movements' entails (e.g., date ranges, limits). With annotations covering safety, this is adequate but not rich in behavioral detail.

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

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

The description is extremely concise and front-loaded, consisting of a single sentence that efficiently conveys the core functionality. Every word earns its place, with no redundant or verbose phrasing, making it easy for an agent to parse quickly.

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

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

Given the tool's low complexity (1 parameter, read-only, no output schema), the description is minimally complete. It covers the basic purpose and API call count but lacks details on output format, error cases, or usage context. With annotations handling safety, this is adequate but leaves gaps for effective tool invocation.

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

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

The description doesn't add any parameter-specific information beyond what the input schema provides. Since schema description coverage is 100% (the 'budget_id' parameter is fully documented in the schema), the baseline score of 3 applies. No additional semantics are offered in the description.

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

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

The description clearly states the tool's purpose: 'List all money movements for a budget (funds moved between categories)'. It specifies the verb ('List'), resource ('money movements'), and scope ('for a budget'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'list_money_movement_groups' or 'get_month_money_movements', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_money_movement_groups' or 'get_month_money_movements', nor does it specify prerequisites, exclusions, or contextual cues for selection. The agent must infer usage from the name and description 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 declare readOnlyHint=true, which the description aligns with by describing a listing operation. The description adds valuable context beyond annotations: it specifies the API call cost ('[1 API call]'), discloses the data fields returned (income, budgeted, activity, ready to assign), and hints at server-state awareness ('last_knowledge_of_server' in schema). However, it doesn't detail pagination, rate limits, or error 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, efficient sentence that front-loads key information (API call cost, action, resource, data fields). Every element earns its place, with no redundant or vague phrasing, making it optimally concise and well-structured for quick comprehension.

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 (listing with filtering), rich annotations (readOnlyHint), and full schema coverage, the description is largely complete. It adds useful behavioral context (API cost, returned fields) but lacks output format details (no output schema) and doesn't cover edge cases like empty results. Slightly more detail on response structure would make it fully complete.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no parameter-specific information beyond implying 'budget_id' usage ('for a budget'). It doesn't explain parameter interactions or provide examples, so it meets the baseline for high schema coverage without adding extra value.

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

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

The description clearly states the specific action ('List all budget months for a budget') and the resource ('budget months'), distinguishing it from siblings like 'get_month' (single month) and 'list_budgets' (budgets themselves). It also specifies the data fields shown (income, budgeted, activity, ready to assign), making the purpose highly specific and differentiated.

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

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

The description implies usage context by mentioning 'for a budget' and the data fields, but provides no explicit guidance on when to use this tool versus alternatives like 'get_month' (single month) or 'list_month_transactions' (transactions within months). It also doesn't mention prerequisites or exclusions, leaving usage decisions to inference.

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

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

The annotation already declares readOnlyHint=true, so the agent knows this is a safe read operation. The description adds useful context about being a single API call, which hints at efficiency/rate limiting considerations. However, it doesn't describe pagination behavior, return format, or other behavioral traits 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 extremely concise with just two parts: the API call count and the core functionality. Every element earns its place, and it's front-loaded with the most important information (what the tool does).

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

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

For a read-only tool with good schema coverage but no output schema, the description is minimally adequate. It states the core purpose but lacks important context about when to use it versus sibling tools, what the return format looks like, or any limitations beyond the single API call mention.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('List transactions') and scope ('for a specific month'), which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'list_transactions' or 'list_account_transactions', which likely have overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_transactions' or 'list_account_transactions'. It mentions '[1 API call]' which hints at efficiency but doesn't explain when this specific month-focused tool is preferred over other listing 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 'readOnlyHint: true' already indicates this is a safe read operation. The description adds minimal behavioral context with '[1 API call]', hinting at performance, but doesn't disclose other traits like rate limits, pagination, or what 'all' entails (e.g., completeness). No contradiction with annotations exists.

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 short phrases, front-loading the key information ('List all payee GPS locations') and including a useful performance hint ('[1 API call]'). Every word earns its place 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?

Given the simple input schema (1 parameter with 100% coverage) and read-only annotation, the description is minimally adequate. However, with no output schema and sibling tools present, it lacks details on return format (e.g., list structure) and differentiation from alternatives, leaving gaps in 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%, with the parameter 'budget_id' fully documented in the schema. The description adds no additional meaning about parameters beyond implying the tool operates on a budget, so it meets the baseline of 3 without compensating value.

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

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

The description clearly states the action ('List all payee GPS locations') and resource ('for a budget'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_payee_location' (singular) or 'get_payee_locations_for_payee', which would be needed for a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_payee_location' (for a single location) or 'get_payee_locations_for_payee' (filtered by payee), leaving the agent without context for 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?

The description adds the constraint '[1 API call]', which is useful context beyond the annotations (which only indicate readOnlyHint: true). However, it doesn't disclose other behavioral traits such as pagination, rate limits, or what 'last-used' means for budget_id, leaving gaps in transparency despite the annotations covering safety.

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—just one sentence with a bracketed note—and front-loaded with the core action. Every element ('[1 API call]', 'List all payees for a budget') serves a clear purpose without waste, making it efficient and easy to parse.

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

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

Given the tool's low complexity (a read-only list operation), 100% schema coverage, and annotations indicating safety, the description is somewhat complete but lacks details on output (no schema provided) and behavioral context like pagination. It's adequate for basic use but could be more informative for an agent handling nuanced scenarios.

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 100% schema description coverage, the input schema fully documents both parameters (budget_id and last_knowledge_of_server). The description doesn't add any meaning beyond this, such as explaining the purpose of 'last_knowledge_of_server' or clarifying 'last-used', so it meets the baseline for high schema coverage without compensating value.

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

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

The description clearly states the action ('List all payees') and resource ('for a budget'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_payee' (which retrieves a single payee) or 'list_payee_transactions' (which lists transactions for a payee), though the distinction is somewhat implied by the verb 'list all'.

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 minimal guidance on when to use this tool, stating only that it lists payees for a budget. It doesn't specify when to use it versus alternatives like 'get_payee' (for a single payee) or 'list_payee_transactions' (for payee-specific data), nor does it mention prerequisites or exclusions, leaving usage context largely 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 description adds '[1 API call]' which provides useful implementation context beyond the readOnlyHint annotation. However, it doesn't disclose other behavioral aspects like pagination behavior, rate limits, authentication requirements, or what happens when no transactions exist for the payee. The annotation covers safety (read-only), so the bar is lower, but more behavioral context would be helpful.

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 - just 8 words plus the API call notation. It's front-loaded with the core functionality and wastes no words. Every element (API call count and core purpose) 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 read-only list operation with good schema coverage but no output schema, the description is minimally adequate. It covers the basic purpose but lacks guidance on when to use it versus similar tools, and doesn't describe return format or pagination behavior. The annotations help with safety context, but more completeness would be beneficial.

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 100% schema description coverage, the schema already documents all 5 parameters thoroughly. The description mentions 'specific payee' which aligns with the required payee_id parameter, but adds no additional semantic context beyond what's in the schema. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('List transactions') and target resource ('for a specific payee'), making the purpose immediately understandable. However, it doesn't differentiate this tool from similar sibling tools like 'list_transactions' or 'list_account_transactions', which would require explicit comparison to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_transactions' or 'list_account_transactions'. It mentions 'specific payee' which implies a filtering context, but offers no explicit when/when-not instructions or named alternatives.

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

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

The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds value by specifying the scope ('all scheduled (recurring) transactions') and noting '[1 API call]', which implies efficiency but does not detail behavioral traits like pagination, rate limits, or error handling. No contradiction with annotations is present.

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

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

The description is extremely concise and front-loaded, consisting of a single sentence with no wasted words. The bracketed '[1 API call]' efficiently conveys additional context without verbosity, making it well-structured and easy to parse.

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

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

Given the tool's low complexity (read-only, 2 parameters with full schema coverage, no output schema), the description is adequate but minimal. It covers the basic purpose and scope but lacks details on output format, error cases, or integration with sibling tools, leaving some contextual gaps for an agent.

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

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

Schema description coverage is 100%, so the input schema fully documents both parameters ('budget_id' and 'last_knowledge_of_server'). The description does not add any additional meaning or context about these parameters beyond what the schema provides, meeting the baseline for high 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 action ('List all scheduled (recurring) transactions') and resource ('for a budget'), making the purpose specific and understandable. However, it does not explicitly distinguish this tool from similar sibling tools like 'list_transactions' or 'get_scheduled_transaction', which would be needed for a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'list_transactions' for non-recurring transactions or 'get_scheduled_transaction' for a single scheduled transaction. It lacks explicit context, prerequisites, or exclusions, offering minimal usage direction.

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

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

The description adds valuable behavioral context beyond the readOnlyHint annotation: it specifies '[1 API call]' (implying a single request, useful for rate limit awareness) and 'Returns most recent transactions first' (ordering behavior not indicated in annotations). This compensates well for the lack of other annotations like rateLimitHint.

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

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

The description is extremely concise—two sentences with zero wasted words. It's front-loaded with the core purpose and efficiently adds key behavioral details. Every sentence earns its place by providing distinct 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?

Given the tool's moderate complexity (filtered listing), rich annotations (readOnlyHint), and full schema coverage, the description is mostly complete. It adds useful behavioral context (API call count, sorting). The main gap is lack of output format details, but since there's no output schema, this isn't severely penalized.

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 100% schema description coverage, the input schema fully documents all four parameters. The description adds no additional parameter semantics beyond implying filtering capabilities ('optional filters'), which is already covered in the schema. This meets the baseline 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 clearly states the verb ('List') and resource ('transactions for a budget'), making the purpose evident. However, it doesn't explicitly differentiate this tool from sibling tools like 'list_account_transactions' or 'list_month_transactions', which also list transactions but with different scopes.

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 'optional filters' but provides no guidance on when to use this tool versus alternatives like 'list_account_transactions' or 'get_transaction'. It lacks explicit when/when-not instructions or named alternatives, leaving usage context implied at best.

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 indicate destructiveHint=true and readOnlyHint=false, which the description aligns with by describing the merge's effects. It adds valuable context beyond annotations: API call costs ('Dry run costs 4 + N calls...'), the outcome ('source category will have zero transactions and zero budgeted amounts'), and the need for manual cleanup. 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 front-loaded with the core action and efficiently covers key points in three sentences. It avoids redundancy, though the initial bracketed terms '[Variable API calls] [Workflow]' are slightly cryptic and could be more integrated.

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 destructive nature (annotations cover this) and no output schema, the description provides good context: it explains the merge process, costs, default behavior, and post-merge state. It could briefly mention error cases or permissions, but overall it's sufficiently complete for a complex operation.

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

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

Schema description coverage is 100%, providing clear parameter details. The description adds minimal semantics beyond the schema, such as noting 'source_category_id' will be emptied and 'dry_run' defaults to true for previewing. This meets the baseline for high schema coverage without significant extra value.

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

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

The description clearly states the specific action ('merges a source category into a target category') and details what this entails ('re-categorizes all transactions and moves all historical budgeted amounts'). It distinguishes from siblings like 'update_category' by focusing on merging rather than modifying individual categories.

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

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

Explicit guidance is provided: 'Defaults to dry_run=true to preview changes before executing' and 'After merging... you can then manually hide/delete it in the YNAB app.' It implicitly contrasts with 'delete_category' by noting manual cleanup is needed post-merge, though it doesn't name alternatives directly.

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

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

The annotation 'readOnlyHint: false' indicates this is a mutation tool, which aligns with the description's 'Update' action. The description adds minimal behavioral context by specifying updatable fields but does not disclose permissions, side effects, or error conditions. No contradiction with annotations exists, but the description could provide more insight 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, efficient sentence with no wasted words. It front-loads the key action and scope, and the bracketed '[1 API call]' provides useful implementation context without verbosity.

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

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

Given the tool's mutation nature, lack of output schema, and no annotations beyond readOnlyHint, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, error handling, or return values, which could be important for an update operation in a budgeting 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 input schema fully documents all parameters. The description mentions 'name, note, or goal', which partially maps to parameters but doesn't add meaning beyond the schema. It doesn't explain interactions between parameters or optionality, relying on the schema for details.

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

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

The description clearly states the action ('Update') and resource ('an existing category'), specifying the editable fields (name, note, or goal). It distinguishes from sibling tools like 'create_category' and 'merge_category' by focusing on modification rather than creation or merging. However, it doesn't explicitly differentiate from 'update_category_group' or 'update_month_category' in terms of 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?

The description provides no guidance on when to use this tool versus alternatives like 'merge_category' or 'update_category_group', nor does it mention prerequisites such as needing an existing category ID. It lacks context about when this tool is appropriate compared to other update operations in the sibling list.

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

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

The description adds minimal behavioral context beyond annotations. Annotations indicate readOnlyHint=false (implying a mutation), which aligns with 'Update'. The description adds that this is '[1 API call]', hinting at a single operation, but doesn't disclose other traits like permissions needed, idempotency, error conditions, or what happens on success/failure. With annotations covering the mutation aspect, this earns a baseline score for adding some 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 extremely concise—just two short phrases with zero wasted words. It's front-loaded with the key action ('Update a category group's name') and includes a useful efficiency note ('[1 API call]'). Every sentence earns its place, making it easy to parse quickly.

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

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

Given the tool's complexity (a mutation with 3 parameters), annotations cover the mutation aspect, and schema coverage is complete. However, there's no output schema, and the description doesn't explain return values or error behavior. For a mutation tool, this leaves gaps in understanding outcomes, making it 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 description coverage is 100%, so the schema fully documents all three parameters (budget_id, category_group_id, name). The description mentions 'name' but doesn't add meaning beyond what the schema provides (e.g., it doesn't explain naming constraints or relationships between parameters). This meets the baseline 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 clearly states the verb ('Update') and resource ('a category group's name'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from similar sibling tools like 'update_category' or 'update_month_category', which would require mentioning what makes a category group different from those other entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid category_group_id), when not to use it, or how it differs from sibling update tools like 'update_category'. This leaves the agent with insufficient context for proper 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?

The annotation 'readOnlyHint: false' already indicates this is a mutation tool. The description adds minimal behavioral context beyond this—it mentions '[1 API call]' which hints at performance characteristics, but doesn't disclose side effects, permissions needed, error conditions, or what happens to existing budgeted amounts. For a mutation tool, more behavioral details would be helpful.

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

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

Two sentences with zero waste. The first sentence states the action and scope, the second explains the purpose. Both sentences earn their place by providing essential information without redundancy.

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

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

For a mutation tool with no output schema and minimal annotations, the description is adequate but incomplete. It covers the basic purpose and scope, but lacks details about return values, error handling, or behavioral constraints. Given the complexity of budget updates, more context would help the agent use 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?

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain relationships between parameters (e.g., how 'budget_id' interacts with 'month') or provide examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Update the budgeted/assigned amount'), the resource ('for a category in a specific month'), and the purpose ('This is how you allocate money to categories'). It distinguishes itself from siblings like 'update_category' (which likely updates category metadata) by focusing on month-specific budget allocation.

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 budget allocation to categories in specific months, but doesn't explicitly state when to use this tool versus alternatives like 'update_category' or 'get_month_category'. No prerequisites or exclusions are mentioned, leaving the agent to infer context from the tool name and description 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?

The annotation readOnlyHint=false correctly indicates this is a write operation, which aligns with the 'Update' action in the description. The description adds minimal context beyond annotations—it specifies the scope ('a payee's name') and notes '[1 API call]', but doesn't disclose behavioral traits like authentication needs, rate limits, or what happens if the name update fails.

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

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

The description is extremely concise—two short phrases with zero waste. It's front-loaded with the key action and resource, and the API call note is a useful efficiency hint without being verbose.

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

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

Given the tool's moderate complexity (a mutation operation with 3 parameters), no output schema, and minimal annotations, the description is somewhat incomplete. It covers the basic purpose but lacks context on usage, error handling, or return values, which would help an agent use it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (budget_id, payee_id, name) with their types, constraints, and defaults. The description adds no additional parameter semantics beyond what's in the schema, making the baseline score 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 ('Update') and resource ('a payee's name'), making the purpose specific and understandable. However, it doesn't differentiate this tool from other update tools like update_category or update_transaction, which would require mentioning it's specifically for modifying payee names rather than other payee attributes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a payee_id from get_payee or list_payees), when not to use it, or how it differs from other update operations on the server.

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

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

The annotation 'readOnlyHint: false' correctly indicates this is a mutation tool, which aligns with the 'Update' action. The description adds minimal behavioral context beyond this—it doesn't mention authentication requirements, rate limits, error conditions, or what happens if only some fields are provided. However, it doesn't contradict the annotation, so it meets the baseline for having 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—just one sentence plus a technical prefix. It's front-loaded with the core action ('Update an existing scheduled transaction'), and there's no wasted text. However, the '[1 API call]' prefix might be unnecessary clutter for an AI agent focused on tool selection rather than implementation details.

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

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

Given the complexity (11 parameters, mutation tool) and lack of output schema, the description is minimally adequate. The annotations cover the mutation aspect, and the schema fully documents inputs, but the description doesn't address what the tool returns, error handling, or side effects. For a tool with no output schema, more context on expected responses would be helpful.

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 100% schema description coverage, the input schema already documents all 11 parameters thoroughly, including descriptions, enums, and required fields. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain relationships between parameters (e.g., that 'payee_id' and 'payee_name' might be alternatives) or provide examples. This meets the baseline score when schema coverage is high.

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 scheduled transaction'), making the purpose unambiguous. It distinguishes from sibling tools like 'create_scheduled_transaction' and 'delete_scheduled_transaction' by specifying it's for updating existing ones. However, it doesn't explicitly differentiate from other update tools like 'update_transaction' in terms of 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a scheduled transaction ID from 'get_scheduled_transaction' or 'list_scheduled_transactions'), nor does it explain when to choose this over similar tools like 'update_transaction'. The '[1 API call]' prefix is technical but doesn't help with usage decisions.

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

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

The annotation readOnlyHint=false correctly indicates this is a mutation tool, but the description adds minimal behavioral context. It mentions '[1 API call]' which hints at performance/rate limit considerations, but doesn't disclose important behavioral traits like whether updates are atomic, what happens with partial updates, if there are validation rules, or what permissions are required. With annotations covering only the read/write aspect, the description carries significant burden for a mutation tool.

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

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

The description is extremely concise with just two phrases: '[1 API call]' and 'Update an existing transaction'. Both phrases earn their place - the first provides API cost context, the second states the core purpose. There's zero wasted language or redundancy.

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

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

For a mutation tool with 12 parameters, no output schema, and minimal annotations, the description is inadequate. It doesn't explain what happens on success/failure, what values are returned, how errors are handled, or provide any examples of typical use cases. The '[1 API call]' hint is useful but doesn't compensate for the lack of behavioral context needed for a complex 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?

With 100% schema description coverage, all parameters are documented in the schema itself. The description adds no additional parameter semantics beyond the generic 'update' concept. It doesn't explain parameter relationships, constraints, or provide examples of typical update patterns. The baseline of 3 is appropriate when the schema does all the parameter documentation work.

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

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

The description clearly states the verb ('Update') and resource ('an existing transaction'), making the purpose immediately understandable. It distinguishes from sibling tools like 'create_transaction' and 'delete_transaction' by specifying it's for existing transactions. However, it doesn't specify what fields can be updated beyond the generic 'update' term.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_transactions' (plural) or 'get_transaction' for viewing. It doesn't mention prerequisites like needing a valid transaction_id or budget context, nor does it explain when this tool is appropriate versus other update tools in the sibling list.

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

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

Annotations already declare readOnlyHint=false, indicating this is a mutation tool. The description adds useful behavioral context about the bulk operation ('[1 API call, bulk]') and the identification requirement, but doesn't disclose other important traits like error handling, rate limits, or what happens when transactions fail. With annotations covering the mutation aspect, this earns a baseline score.

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 just two sentences that both earn their place. The first sentence establishes the bulk operation scope, the second provides critical identification requirements. No wasted words or 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?

For a mutation tool with no output schema and 100% schema coverage, the description provides adequate but minimal context. It covers the bulk nature and identification requirements, but lacks information about response format, error conditions, or transactional behavior. Given the complexity of updating multiple transactions, more behavioral context would be helpful.

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 fully documents both parameters. The description adds minimal value beyond the schema - it mentions the identification requirement (id or import_id) which is already in the schema, but doesn't provide additional semantic context about parameter usage or constraints. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Update multiple transactions at once') and resource ('transactions'), distinguishing it from sibling tools like 'update_transaction' (singular) and 'create_transactions'. The bulk nature is explicitly mentioned, providing 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 implies usage context through the bulk operation mention and identification requirement ('Each must include either id or import_id'), but doesn't explicitly state when to use this versus alternatives like 'update_transaction' (singular) or 'create_transactions'. No explicit when-not or alternative guidance is provided.

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