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

With no annotations, the description carries the full burden. It discloses important behaviors: frequency values limitation (multi-word rejected by YNAB backend), dry_run parameter for preview, and default budget_id. It could mention if changes are reversible or auth requirements.

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 well-structured with a header and bullet points. It is slightly long but every sentence adds value. No redundancy.

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

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

Given 10 parameters, 0% schema coverage, and no annotations, the description covers all parameters, explains behavior, and mentions a dry run feature. Output schema exists, so return values need not be described. Complete for 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 coverage is 0%, so description must compensate. It provides detailed explanations for all 10 parameters, including amount format ('-42.50' for outflow), date format (YYYY-MM-DD), frequency caveat, and default for budget_id. This adds significant meaning beyond the schema.

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

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

The description clearly states 'Create a scheduled (recurring) transaction in YNAB,' which is a specific verb and resource. It distinguishes from siblings like create_transaction by specifying 'recurring.'

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 recurring transactions but does not explicitly state when to use this tool over alternatives like create_transaction or when not to use it. No exclusions or alternatives 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?

No annotations are provided, so the description carries the burden. It explains key behaviors: amount sign convention, date format, auto-creation of payee via payee_name, and dry_run for preview. It lacks details on error handling, idempotency, or return value, but the output schema may cover the latter.

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 starts with a clear purpose followed by a well-structured bullet-like list of parameters. It is fairly concise given the number of parameters (10), though some lines could be shortened. No wasted sentences.

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 of 10 parameters and no annotations, the description covers all parameter semantics and flags key behavior (auto-created payee, dry_run). It does not mention possible errors, rate limits, or response format, but the existence of an output schema mitigates the last point. Overall, it is quite complete.

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

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

The description adds significant meaning beyond the input schema, which has no descriptions. It explains each parameter with examples and defaults, such as amount format, date format, payee auto-creation, and dry_run purpose. This fully compensates for the 0% schema description 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 'Create a transaction in YNAB,' which is a specific verb+resource. It distinguishes from sibling tools like create_scheduled_transaction and create_transactions by focusing on a single immediate transaction.

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

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

The description lists all parameters with explanations, including dry_run for validation. However, it does not explicitly state when to use this tool versus alternatives like create_transactions, though the distinction is implied by the name and parameter differences.

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

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

No annotations are provided, so the description bears the full burden. It states the tool creates transactions, implying a write operation, and mentions a 'dry_run' option for preview. However, it does not disclose potential side effects, authorization requirements, or rate limit specifics beyond the guideline.

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

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

The description is concise: a one-sentence purpose, one guideline sentence, then a structured Args list. Every part earns its place with no redundancy.

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

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

The description covers the tool's purpose and parameters well but lacks any description of the return value or output schema (even though one exists). With 23 sibling tools, it only differentiates from one ('create_transaction'), leaving other alternatives unaddressed.

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 schema description coverage at 0%, the description compensates well by detailing the fields of 'transactions_json' (including types and dollar format), explaining 'dry_run' as validation only, and noting 'budget_id' defaults to last-used. This adds significant meaning beyond the schema's type definitions.

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 'Create multiple transactions in YNAB in a single API call', specifying the verb, resource, and batch scope. It effectively distinguishes from the sibling tool 'create_transaction' by noting this is for multiple transactions.

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

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

The description explicitly says 'Preferred over create_transaction when creating multiple transactions to minimize rate limit usage', providing a clear when-to-use and rationale. It does not include when-not-to-use exclusions but is sufficient.

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

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

No annotations are present, so the description bears full responsibility. It mentions the dry_run parameter for validation without deletion, adding transparency. However, it does not state that deletion is irreversible or require confirmation, leaving some behavioral aspects unclear.

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

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

The description is concise, using a clear docstring format with an Args section. It is front-loaded with the main purpose and then details parameters. No unnecessary information is present.

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 existence of an output schema, the description does not need to cover return values. However, as a delete operation with no annotations, it could mention success/failure indicators or error conditions. The description is adequate but leaves some context unaddressed.

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% schema description coverage, the description compensates by listing all three parameters and adding meaning: scheduled_transaction_id is a UUID, budget_id defaults to last-used budget, and dry_run validates without deleting. This provides useful context beyond the schema's type definitions.

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

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

The description clearly states 'Delete a scheduled transaction from YNAB', identifying the specific verb and resource (delete, scheduled transaction). This distinguishes it from sibling tools like create_scheduled_transaction and update_scheduled_transaction.

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

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

No explicit guidance on when or when not to use this tool is provided. While the purpose is clear, there is no description of prerequisites, such as ensuring the scheduled transaction exists, or mentioning alternatives for similar 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 description discloses the destructive nature ('Delete') and includes a dry_run parameter for preview, which adds transparency. However, it does not discuss reversibility, effects on budget, or error handling for missing transactions.

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

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

The description is concise: a single sentence followed by a bullet list of arguments. It is front-loaded with the core action and every sentence adds value 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?

Given no annotations and only 3 parameters, the description covers the basic operation but lacks details on return values (though output schema exists), edge cases, and behavioral context like what happens after deletion.

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% schema description coverage, the description adds meaningful explanations for all three parameters: transaction_id ('UUID to delete'), budget_id ('Defaults to last-used budget'), and dry_run ('Validate and preview without deleting'). This compensates well for the schema's lack of 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 'Delete a transaction from YNAB' with a specific verb and resource. However, it does not explicitly differentiate from sibling tools like delete_scheduled_transaction, though the context distinguishes it as a regular transaction deletion.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., delete_scheduled_transaction). Prerequisites like transaction existence or constraints like reconciled transactions are not mentioned.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool is a read operation returning full details, and mentions default behavior for budget_id. However, it does not discuss side effects, rate limits, or authorization requirements.

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

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

The description is very concise: a single sentence for purpose, a sentence listing returned fields, and a structured argument list. No wasted words, and the key information is front-loaded.

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

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

Given that an output schema exists, the description does not need detailed return value explanations, but it still lists key fields. It covers the main purpose and parameter defaults. Minor omission: no guidance on errors or prerequisites, but overall sufficient for a simple get 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 0%, but the description adds meaning by explaining that budget_id defaults to last-used budget and that account_id is a UUID. It also hints at return fields, which indirectly clarifies parameter purpose. Baseline is 3 due to low coverage, and description adds marginal 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 tool retrieves a single YNAB account with full details, specifying the verb 'get' and the resource 'account'. It distinguishes from sibling tools like list_accounts by focusing on a single account and listing returned fields.

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

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

The description implies usage when needing detailed information for one account and notes that budget_id defaults to last-used budget, but it does not explicitly state when to use this over alternatives like list_accounts or provide exclusions.

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

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

With no annotations, the description carries the full burden. It implies a read-only operation via the verb 'Get', but does not explicitly state behavioral traits such as no side effects, authorization needs, or rate limits. The transparency is adequate but not thorough.

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 defining the purpose plus one line for the parameter. It is front-loaded and contains no filler. Every word contributes to understanding.

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

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

Given the presence of an output schema, the description does not need to detail return values. It covers the core purpose and parameter. Minor gaps include lack of error conditions or prerequisites, but for a simple getter it is largely 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?

Despite 0% schema coverage, the description adds value by explaining the budget_id parameter: 'Budget ID. Defaults to last-used budget.' This provides default behavior context that the schema alone does not convey. Coverage is full for the single parameter.

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

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

The description explicitly states 'Get budget settings including date and currency format,' clearly identifying the verb and resource. This distinguishes it from sibling get_ tools like get_account or get_category, which operate on different 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?

No guidance is provided on when to use this tool versus alternatives. There are many sibling tools, and the description does not specify exclusions, prerequisites, or scenarios where another tool would be more appropriate.

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

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

With no annotations, the description carries full burden. It mentions returns (budgeted, activity, balance, metadata) and defaulting of budget_id, but does not disclose read-only nature, authentication needs, or error scenarios.

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: three short lines of description plus a two-line args section. Purpose is front-loaded, and every sentence is necessary.

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 and the presence of an output schema, the description adequately covers return values and parameter defaults. Could mention error cases but not required for minimal 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 coverage is 0%, and the description adds meaning by listing arguments with brief definitions (category UUID, budget ID with default behavior). This compensates well for absent 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 it gets a single YNAG category with budget details, specifying the verb and resource. It distinguishes from sibling list_categories by focusing on a single category.

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

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

No explicit guidance on when to use this vs alternatives like list_categories or update_category. The description implies usage for a single category but lacks exclusions or 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?

Without annotations, the description carries full burden and discloses the return value format. It doesn't mention error cases or rate limits, but the read-only nature is implied by the verb 'Get' and the description of returns.

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

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

The description is concise, with a clear introductory sentence, a bullet-point-style list of return values, and a structured Args section. Every sentence is useful and front-loaded.

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

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

Given the presence of an output schema, the description does not need to detail return values, but it does so helpfully. It covers the main behavior but could mention what happens if the month is invalid or the budget_id is wrong.

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 provides crucial meaning for both parameters, including the month format and special 'current' value, and the budget_id default. This adds significant value beyond the input schema which has no 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 it gets a single budget month with per-category breakdown, specifying the resource and verb. It distinguishes from siblings like list_months by emphasizing the detailed breakdown.

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

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

The description clearly indicates this tool is for retrieving a detailed single month, and notes the default for budget_id. However, it does not explicitly contrast with list_months or mention when not to use it.

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

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

With no annotations, the description must disclose behavior. It only says 'Get a single payee' and omits side effects, error conditions, or authentication requirements.

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

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

Description is very short and to the point, using Args format. No redundant information.

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

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

Given the simplicity of a get-by-ID tool, the description is adequate but could mention the output schema or coordinate with list_payees. Returns are covered by output schema.

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

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

Schema description coverage is 0%, so description adds value by mentioning budget_id defaults to last-used. But both parameters are described minimally, matching schema titles.

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

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

The description clearly states it retrieves a single payee, differentiating from list_payees which lists all. However, it doesn't explain what a payee is in YNAB.

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

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

No guidance on when to use this tool vs alternatives like list_payees or update_payee. Only mentions default budget behavior.

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?

Discloses return includes subtransactions, but missing error handling, authorization needs, or read-only guarantee. No annotations to offset.

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?

Succinct three sentences, front-loaded with purpose, no wasted words.

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

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

Covers purpose and params well; output schema exists so return details not needed. Lacks error scenarios but adequate for simple retrieval.

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?

Provides clear descriptions for both parameters (UUID and budget default) beyond schema, compensating for 0% 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?

Clearly states 'Get details of a single scheduled transaction' with a specific verb and resource. Includes mention of subtransactions, distinguishing it from list siblings.

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

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

Implies when to use (get details of one) vs. list, but lacks explicit when-not-to-use or alternative selection guidance.

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

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

No annotations provided, so the description must fully disclose behavioral traits. It does not mention that the operation is read-only, what happens if the transaction is not found, or any auth/rate-limit concerns. The phrase 'with full details' is vague and insufficient.

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

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

The description is short and to the point, using a docstring-style format. It omits unnecessary fluff but could be trimmed further. The information is front-loaded and each sentence serves a 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?

With an output schema present, the description does not need to explain return values. However, it lacks usage guidelines and behavioral traits. For a simple 2-parameter tool, it is mostly adequate but has notable 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?

Although schema coverage is 0%, the description adds meaning by explaining both parameters: transaction_id (UUID) and budget_id (defaults to last-used budget). This provides useful context beyond the schema, especially the default behavior for budget_id.

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

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

The description clearly states 'Get a single YNAB transaction with full details,' specifying the verb (get) and resource (transaction). It effectively distinguishes this tool from siblings like list_transactions (returns multiple) and update_transaction (mutates).

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

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

No guidance on when to use this tool versus alternatives (e.g., get_account, get_category) or any prerequisites. The description lacks explicit when-to-use or when-not-to-use context, leaving the agent without comparative 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?

No annotations are provided, so the description carries the full burden. It states the tool is a read operation returning user ID but does not mention that it is safe, non-destructive, or any authentication requirements. For a simple read-only tool, this is adequate but lacks explicit safety hints.

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

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

The description consists of two concise sentences with no extraneous information. Every word is necessary and front-loaded with the key action and return 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 zero parameters and the existence of an output schema, the description is nearly complete. It could optionally mention that the user ID is used in other API calls, but this is not essential for correct tool usage.

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

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

The input schema has no parameters, and schema description coverage is 100%. The description does not need to add parameter information. Baseline for zero parameters is 4, and the description adds no extra semantic value beyond what is already clear.

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

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

The description clearly states the tool retrieves the authenticated YNAB user and returns the user ID. The verb 'get' and resource 'user' are specific, and it distinguishes itself from sibling tools that operate on other entities like accounts or 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?

While no explicit when-to-use or when-not-to-use guidance is given, the description is self-evident: use this tool to get the authenticated user's ID. The context of sibling tools (all CRUD on different resources) implicitly differentiates it, but a mention of alternatives is not necessary here.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions default budget behavior ('If not provided, uses the default budget.') but fails to disclose other traits like idempotency, read-only nature, error handling, or response format beyond 'with balances'. Minimal transparency.

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

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

The description is extremely concise: two sentences and a parameter description. No wasted words, and all sentences contribute value. It is well-structured and front-loaded with the core purpose.

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

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

For a simple list tool with one optional parameter and an output schema, the description is moderately complete. It covers core functionality and the default behavior. However, it misses details like expected output structure (though output schema exists), error conditions, or required permissions. Adequate but has 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?

The description adds significant meaning to the single parameter 'budget_id' by explaining it is a 'Budget ID' and specifying default behavior. Since the input schema has no descriptions (0% coverage), the description effectively compensates, though examples or type constraints could further enhance clarity.

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

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

The description clearly states the tool's purpose: 'List all accounts for a YNAB budget with balances.' It specifies the verb 'list', the resource 'accounts', and the context 'for a YNAB budget', including the nuance 'with balances'. This is specific and distinct from sibling tools like 'get_account' (single account) and others.

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

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

The description does not provide any guidance on when to use this tool versus alternatives such as 'get_account' or other list tools. No explicit context on usage scenarios, prerequisites, or exclusions is given.

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

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

Describes output fields (names, IDs, dates) and implies read-only behavior. No annotations exist, so description carries burden; it covers the key behavioral trait of returning budget metadata.

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

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

Three efficient sentences: purpose, output summary, usage guidance. No waste, front-loaded with core action.

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

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

Simple tool with no parameters and an output schema. Description sufficiently explains what it returns and how to use the result, making it complete for agent 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?

No parameters, and schema coverage is 100%. Description adds value by listing return fields, which compensates for the lack of parameter information. Baseline for 0 params is 4.

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

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

Clearly states it lists all budgets for the authenticated YNAB user. The verb 'list' and resource 'budgets' are specific, and no sibling tool overlaps in purpose.

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

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

Explicitly notes that the budget ID from this tool should be used with other tools to target a specific budget, providing clear context for when to use it. Lacks explicit 'when not to use' but is sufficient given sibling diversity.

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

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

No annotations provided, so the description carries full burden. It implies a read operation but does not explicitly state safety, error conditions, or side effects. It's adequate but minimal.

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

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

The description is three sentences with a clear args section, front-loaded with the main action. No unnecessary 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 simple list tool with an output schema, the description sufficiently covers purpose, return value, and parameter usage. No gaps.

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

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

The schema has 0% description coverage, but the description adds meaningful context for the single parameter budget_id, explaining its optionality and default behavior.

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 lists all categories for a YNAB budget, grouped by category group, and returns names and IDs. It distinguishes itself from siblings like get_category and list_accounts.

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

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

It explains when to use the budget_id parameter and that it defaults to the default budget, but does not explicitly mention when not to use this tool or alternative tools for similar tasks.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It explains that budget_id is optional and defaults to the user's default budget, but it does not mention any potential behaviors like pagination, rate limits, or whether the tool is read-only (though it is likely safe). The description is adequate 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 concise and well-structured. The first line gives the main purpose, followed by a bullet-like list of return fields, then the Args section. Every sentence adds value without redundancy. It is appropriately front-loaded.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema (not shown but indicated), the description is sufficiently complete. It explains the return fields and parameter behavior. However, it could mention any sorting or filtering options to be completely exhaustive, but it is not necessary for basic usage.

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

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

The input schema has 0% description coverage, so the description must compensate. It adds meaning by explaining that budget_id is optional and defaults to the default budget if not provided. This provides semantic guidance beyond the schema's type definition.

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 what the tool does: 'List all budget months with summary figures.' It specifies the verb (list) and resource (budget months), and lists the return fields (income, budgeted, etc.). This distinguishes it from sibling tools like get_month (single month) or list_accounts.

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

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

The description provides basic usage guidance by explaining the optional budget_id parameter and its default behavior. However, it does not explicitly state when to use this tool vs. alternatives (e.g., get_month for a specific month), nor does it mention any prerequisites or contextual scenarios.

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

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

No annotations are provided, so the description carries the burden. It discloses the default budget behavior, which is a key behavioral trait. It does not mention side effects, but as a read-only list operation, the absence is acceptable.

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 three short sentences. It front-loads the core purpose and adds parameter details efficiently, with no unnecessary words.

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

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

For a simple list tool with one optional parameter and an output schema, the description is complete. It explains the return content and parameter usage, requiring no additional context.

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

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

The description provides meaningful explanation for the budget_id parameter beyond the schema, including its purpose and the default behavior when omitted. This compensates for 0% schema description 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 it lists all payees for a YNAB budget and returns payee names and IDs. It distinguishes from sibling tools like list_accounts or get_payee by specifying its exact resource and action.

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

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

The description explains the optional budget_id and default behavior, but lacks explicit guidance on when to use this tool versus alternatives like get_payee. However, the purpose is straightforward for a list-all 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?

No annotations provided. The description does not disclose behavioral traits such as pagination, filtering, authorization requirements, or limits. It only states returns frequency, next date, etc., but not how the list is ordered or if there are any restrictions.

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?

Concise, front-loaded main sentence, followed by a clear bullet list of return fields. The Args section is efficient. No unnecessary 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 an output schema exists, the description sufficiently lists the return fields. However, it lacks guidance on distinguishing from sibling list tools and does not mention any pagination or filtering, which would be important for 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 0%, but the description adds meaning: 'budget_id: Budget ID. If not provided, uses the default budget.' This clarifies the default behavior beyond the schema's type and default.

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

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

Clearly states the verb 'list', the resource 'scheduled transactions', and the scope 'for a YNAB budget'. It differentiates from 'get_scheduled_transaction' (single) and 'list_transactions' (non-scheduled).

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

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

No explicit guidance on when to use this tool vs alternatives like 'get_scheduled_transaction' or 'list_transactions'. Does not mention when not to use it.

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

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

No annotations exist, so description must cover behavioral traits. It states the tool returns transactions but does not explicitly declare read-only nature, rate limits, or auth needs. Adequate but not comprehensive.

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

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

Description is concise (8 lines), well-structured with a brief intro followed by parameter list. Every sentence adds value; no waste.

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

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

With output schema present, return value details are not needed. Description covers key logic (date range, mutually exclusive filters) for a list tool. Slight gap: no mention of pagination or result limits.

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

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

Schema coverage is 0%, so description adds significant meaning: explains mutual exclusivity of filters, date format, and type values. Adds value beyond bare 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 'List transactions from YNAB with optional filters,' using a specific verb and resource. It distinguishes from siblings like get_transaction (single) and list_scheduled_transactions (different type).

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

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

Description provides clear usage context: returns transactions since a given date, with optional mutually exclusive filters. It implies when to use (list filtering) vs alternatives, though explicit when-not is absent.

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

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

With no annotations, the description carries the burden. It discloses a dry_run parameter for previewing changes, but does not mention side effects, authentication requirements, or what happens when the category_id is invalid. The description's behavioral detail is adequate but not comprehensive.

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

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

The description is concise with a single sentence for purpose, a usage guideline, and a bulleted parameter list. Every sentence serves a purpose and there is no redundant information.

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

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

Given the presence of an output schema, the description appropriately focuses on inputs. It covers the key aspects of the operation (partial updates, dry run, default budget). It lacks information about error handling or edge cases, but overall it is sufficient for a simple update 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?

Despite 0% schema description coverage, the description provides brief yet meaningful explanations for each parameter (e.g., 'hidden: Whether to hide the category'). This compensates for the schema's lack of descriptions, though some parameters could benefit from more detail (e.g., expected format for note).

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 the resource ('category metadata in YNAB'). It distinguishes the tool from siblings like update_category_budget by focusing on metadata fields (name, note, hidden) rather than budget allocations.

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 advises to only provide fields to change, which guides partial updates. It also notes the default for budget_id. However, it does not include explicit when-not-to-use or alternative tool recommendations.

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

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

The description discloses the dry_run parameter's behavior (preview without updating) but does not mention other behavioral traits such as idempotency, overwrite semantics, required permissions, or side effects. No annotations exist to compensate.

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

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

The description is concise: a single sentence for purpose followed by a structured Args block that is efficient and front-loaded. Every sentence adds value, with no redundancy or fluff.

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

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

Given the presence of an output schema (context indicates it exists), the description covers parameter semantics and dry_run behavior adequately. However, it could mention idempotency or effects on existing budgets, though not critical.

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

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

The description adds detailed semantics for all 5 parameters (e.g., month format, amount as dollar, budget_id default, dry_run purpose) beyond the schema's type-only definitions. With 0% schema description coverage, this is essential and well-done.

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

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

The description clearly states the verb 'set' and resource 'budgeted amount for a category in a specific month', making the tool's purpose unambiguous. It distinguishes itself from sibling tools like create_transaction or update_category by specifying budget assignment to a month.

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

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

The description implicitly indicates usage by defining the operation, but it lacks explicit guidance on when to use this tool versus alternatives or when not to use it. No exclusions or context about prerequisites are provided.

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

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

No annotations provided, so the description must disclose behavioral traits. It only states it updates/renames, but lacks details on idempotency, side effects, permissions, error handling, or what happens if the payee doesn't exist.

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

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

The description is extremely concise: a one-line summary followed by a clean bullet list of arguments. No unnecessary words.

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

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

Given the tool's simplicity and the presence of an output schema, the description is mostly complete. It covers the main behavior and all parameters. However, it could mention error conditions or prerequisites (e.g., payee must exist) for full 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 0%, so the description compensates by explaining each parameter's meaning (e.g., 'Payee UUID', 'New name for the payee', defaults for budget_id, behavior of dry_run). This adds significant value beyond the schema titles.

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 'payee' with the specific purpose 'rename'. It distinguishes from sibling tools like get_payee, list_payees, and other update tools.

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

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

No guidance on when to use this tool versus alternatives. There is no comparison to sibling tools like update_transaction or create_transaction, nor any mention of prerequisites or preferred contexts.

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?

Discloses important behavioral traits: frequency single-word limitation (explains API rejection and workaround via UI), and dry_run for validation. No annotations provided, so description carries burden. Lacks details on authorization, idempotency, or side effects, but covers key points.

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?

Concise and well-structured: one-line purpose, a usage guideline, then a clear argument list. No unnecessary words. Every sentence adds value.

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

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

Covers essential aspects for an update tool with 11 parameters and an output schema. Explains frequency limitation and dry_run. Could include usage example or error scenarios, but overall adequate.

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

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

Adds meaning beyond schema: each parameter is described (e.g., 'New first date (YYYY-MM-DD)', 'New dollar amount', 'Scheduled transaction UUID'). Schema coverage is 0%, so description compensates well. Could clarify flag_color possible values, but overall informative.

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 'Update fields of an existing scheduled transaction' with a specific verb and resource. It distinguishes from sibling tools like create_scheduled_transaction and delete_scheduled_transaction.

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

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

Provides explicit guidance: 'Only provide the fields you want to change.' Also details frequency constraints and the dry_run parameter. Could improve by explicitly stating when not to use this tool versus alternatives, but the context is clear.

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

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

Discloses dry_run behavior as 'Validate and preview without updating', default budget_id behavior, and that only provided fields are changed. No annotations provided, so description carries burden well.

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?

Well-structured with clear initial sentence, usage guideline, and arg list. Slightly long but no extraneous text; front-loaded with 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?

Covers all parameters, notes default budget, includes dry_run. Does not discuss error cases or return values (output schema present). Generally complete for a mutation tool with many optional fields.

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

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

Schema coverage is 0%, but the description adds clear meaning for each parameter (e.g., amount format, cleared values). Compensates fully for missing 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?

Clearly states 'Update fields of an existing YNAB transaction' with verb+resource. Distinguishes from siblings like create/delete/update_scheduled implicitly, but not explicitly.

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

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

Provides the guideline 'Only provide the fields you want to change.' Does not give explicit when-to-use vs. alternatives like create_transaction or update_scheduled_transaction.

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