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

No annotations are provided, so the description must fully cover behavioral traits. It discloses that the tool is read-only and mentions the report source, but does not describe error handling, permission requirements, response format, or what happens if the account is invalid. The description is insufficient for an agent to understand side effects or limitations.

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

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

The description is two sentences, front-loaded with the primary purpose, and avoids unnecessary words. It could be slightly more structured by breaking down the outputs explicitly, but it is concise and informative.

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

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

Given the lack of an output schema and annotations, the description should explain the return format more completely. It lists the output fields (opening balance, etc.) but does not specify whether the result is a single object or list, data types, or pagination. For a summary tool with 5 parameters, the description provides adequate but not thorough 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% coverage with descriptions for all 5 parameters. The description adds minimal extra meaning beyond the schema (e.g., 'supports department filtering' is already in the schema). According to guidelines, baseline is 3 when coverage is high, and the description does not significantly enhance parameter understanding.

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

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

The description clearly states the tool gets a period summary for an account, specifying the exact outputs (opening balance, total debits/credits, closing balance, transaction count), and distinguishes it from sibling tools like 'query_account_transactions' and other summary tools.

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

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

The description mentions it uses the General Ledger report and supports department filtering, but provides no explicit guidance on when to use this tool versus alternatives like 'get_balance_sheet' or 'query_account_transactions'. It lacks usage context or when-not-to-use instructions.

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

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

With no annotations, the description carries full burden. It discloses auto-lookup behavior and the header-only department constraint. However, it does not mention authentication requirements, potential side effects of creation, or error handling behavior, leaving gaps 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 two sentences, each earning its place. The first sentence states the core purpose and auto-lookup feature. The second delivers a critical constraint and return info. No fluff or redundancy.

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

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

For a tool with 11 parameters and no output schema, the description provides a good overview, including a key constraint. It could be more complete by detailing the return format (e.g., what fields are in 'bill details') and the draft parameter's behavior beyond 'validate and show preview'.

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

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

The schema has 100% coverage with descriptions for all parameters. The description adds value by explaining the auto-lookup mechanism and the department constraint, which are not fully captured in individual parameter descriptions. This goes beyond a baseline of 3.

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

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

The description clearly states 'Create a vendor bill' and mentions key capabilities like auto-lookup of names. However, it does not explicitly differentiate from sibling tools like create_bill_payment or create_expense, leaving some ambiguity about when to use this 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 specific guidance: for multi-department splits, create separate bills. It also explains the draft parameter. However, it lacks comparative guidance on when to use this tool versus other creation tools (e.g., create_expense, create_journal_entry), which limits decision support.

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 discloses key behaviors: it pays bills and applies credits, defaults amounts to open/remaining balances, supports a draft mode, and returns payment details and a link. It could mention it reduces bill balances, but overall it is transparent.

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

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

The description is two sentences that are dense with information, front-loaded with the purpose and flow. 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 the tool's complexity (9 params, nested objects), the description covers the overall flow, defaults, use case, and return value. It lacks explicit mention of vendor consistency constraints but otherwise is complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minimal extra meaning beyond the schema, though it contextualizes the draft parameter's purpose. The default amount behavior is 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 creates a bill payment, explains it as the QBO 'check/pay bills' flow, and specifies it pays bills and applies vendor credits to clear AP. This distinguishes it from siblings like create_bill or create_expense.

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 concrete guidance: 'Use this to record vendor ACH/EFT debits or checks so the bank feed can match them — especially when a bank charge equals bills minus credit memos.' It implies it's for paying existing bills but doesn't explicitly exclude other 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 provided, so description carries full burden. It mentions returns details and a link, but does not disclose behaviors like uniqueness enforcement, failure modes, authentication needs, or rate limits. The draft mode effect is not described.

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

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

Three sentences efficiently covering purpose, inputs, and output. Front-loaded with the 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?

Given 19 parameters and no output schema, description covers input types and return value but lacks edge cases (e.g., duplicate display_name, unresolved parent_ref, draft mode impact). Adequate but not thorough.

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

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

Schema coverage is 100% with descriptions for all parameters. Description adds grouping context ('name parts, contact info, addresses') and mentions parent_ref for sub-customers, but does not significantly surpass schema 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?

Description clearly states 'Create a customer or sub-customer' and specifies accepted inputs (name parts, contact info, addresses, hierarchy settings). It distinguishes from sibling tools like edit_customer by focusing on creation.

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 implies usage for creation and sub-customers, but does not explicitly state when to use this tool versus alternatives (e.g., edit_customer for updates). No exclusion criteria provided.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: automatic ID lookup, line item computation of total by QuickBooks, and return of deposit details with a link. However, it does not mention authorization requirements, error handling, or reversibility, which are non-critical but would enhance 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 concise (three sentences) and front-loaded with the primary action. Every sentence adds distinct information without redundancy. It efficiently covers the tool's purpose, key parameters, and output.

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 7 parameters and no output schema, the description adequately explains the return value (details and link) and covers the behavior of line items. It lacks error condition details or validation notes, but overall provides sufficient context for the agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the auto-lookup for names, the sign convention for amounts (positive income, negative fees), and that QuickBooks computes totals. This provides meaning beyond the schema field 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 'Create a bank deposit' with a specific verb and resource. It distinguishes itself from sibling tools (e.g., create_invoice, create_bill) by focusing on deposits. The additional detail about accepting names and auto-lookup reinforces its unique purpose.

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

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

The description implicitly indicates usage (recording bank deposits) and highlights the auto-lookup feature, but does not explicitly state when to use it versus alternatives like create_sales_receipt or create_expense. No exclusion criteria are provided, which is a minor gap.

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 description carries full burden. Discloses immutability of payment_type, that department is header-level only, auto-lookup of IDs, and returns expense details with a link to QuickBooks. No contradictory information.

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?

Five sentences, each adding distinct information. No redundant or filler content. Front-loaded with primary purpose. Very 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 11 parameters and no output schema, the description covers the general flow, key constraints, auto-lookup behavior, draft mode, and return value (details + link). Sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, but description adds significant value: explains auto-lookup behavior for names, confirms immutability of payment_type, and clarifies that department is header-level. Example placeholders like 'Simplisafe' and 'PLAT BUS CHECKING' help the agent.

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?

Starts with 'Create an expense (Purchase)' – clear verb+resource. Distinguishes from siblings like create_bill, create_deposit by specifying accepted payment types (Cash, Check, CreditCard) and providing a sample description.

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 context: accepts names for lookup, covers three payment types, notes that PaymentType cannot be changed after creation, and DepartmentRef is header-level only. However, it does not explicitly differentiate from alternatives like create_bill, which may be used for similar purposes.

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

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

With no annotations, the description carries the full burden. It discloses automatic ID lookups, draft mode behavior, and that online payment flags must be explicitly set (company defaults don't apply). This adds significant behavioral context beyond the schema, though rate limits or auth needs are not mentioned.

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 compact (4 sentences) and front-loaded with the core purpose. Every sentence adds value, with no redundant information. It is 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 (15 parameters, no output schema), the description covers key aspects: mandatory fields, lookup behavior, line item requirements, draft mode, and online payment flag handling. It could mention error handling for failed lookups, but overall it is thorough.

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

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

Schema coverage is 100%, but the description adds critical meaning: explains the lookup mechanism for names, the requirement for customer, the line item structure (SalesItemLineDetail), and the draft default. This goes beyond the schema descriptions, providing essential context for correct usage.

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

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

The description clearly states 'Create an invoice' and specifies it accepts names for automatic ID lookup. This differentiates it from sibling tools like create_sales_receipt, establishing a distinct verb+resource scope.

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

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

It explicitly states that either customer_name or customer_id is REQUIRED, and that lines use SalesItemLineDetail rather than accounts, providing clear context. However, it does not explicitly list when not to use this tool or name alternatives beyond what is implied by sibling 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?

Without annotations, the description carries the transparency burden. It discloses key behaviors: auto-lookup of account/department names, validation of debits=credits, and return of entry details with a link. However, it omits behaviors like draft flag behavior and permission 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?

Three concise sentences: purpose, feature, output. No fluff or redundancy. Front-loaded with the action and resource.

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 (5 parameters, no output schema), the description covers key aspects but misses the behavior of the 'draft' parameter and does not fully describe the return value structure beyond 'details and a link'. Schema coverage helps, but the description could be more complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying that account and department names can be used (auto-lookup), which is not evident from the schema alone. Other parameters are adequately described in the schema.

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

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

The description clearly states the tool creates a journal entry, distinguishing it from sibling tools like create_invoice or create_bill. It mentions validation and automatic lookup, which adds specificity.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies it is for journal entries, but does not provide criteria or exclusions relative to other creation tools.

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

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

With no annotations, the description carries full burden. It discloses that it accepts names for auto-lookup and returns receipt details and a link. However, it does not mention side effects (e.g., recording a transaction), prerequisites (e.g., authentication), or error handling (e.g., what happens if lookup 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 three sentences long, each sentence carrying distinct value: purpose, key behavior, and output. No redundant or filler content.

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

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

Given 10 parameters, no output schema, and no annotations, the description covers the main behaviors and output. However, it omits mention of the draft parameter's default (true), which is important for understanding the tool's validation mode. Overall, it is fairly complete.

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

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

Schema coverage is 100%, so each parameter is already described. The description adds value by highlighting the auto-lookup pattern and the critical distinction that lines should refer to items, not accounts. This is additional context beyond the schema's individual descriptions.

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

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

The description clearly states the tool creates a sales receipt, emphasizes that lines reference items (products/services) not accounts, and distinguishes from siblings like edit_sales_receipt and get_sales_receipt. It also mentions automatic ID lookup and returns details and a link.

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

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

The description provides a key guideline: lines reference items not accounts, which helps avoid misuse. It also mentions the automatic ID lookup feature. However, it does not explicitly contrast with similar tools like create_invoice or explain when to choose this tool over 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 description notes that the tool performs automatic name-to-ID lookups and returns credit details plus a QuickBooks link, which adds useful behavioral context. However, it does not disclose whether the operation is destructive, idempotent, or requires specific permissions, leaving some gaps given the lack of annotations.

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

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

The description is extremely concise: two sentences that front-load the primary action and key features. Every sentence adds critical information without 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 complexity (10 parameters, no output schema, no annotations), the description explains the basic concept and return value adequately. However, it omits details like error handling, the default for 'draft', or how to structure lines more precisely, leaving some gaps for a fully informed 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?

The input schema already covers 100% of parameters with descriptions, so the baseline is 3. The description enhances understanding by explaining that name fields are for automatic ID lookup and that lines represent credit amounts applied to expense accounts, adding value beyond the schema.

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

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

The description clearly states the tool's action ('Create a vendor credit') and specifies the key resource and behavior: accepting names with automatic ID lookup and representing lines as credit amounts applied to expense accounts. This distinctly sets it apart from sibling tools like create_bill or create_expense, which have different purposes.

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 explicit guidance on when to use this tool versus alternatives (e.g., create_bill for vendor payments). While the name and context imply its use for vendor credits, an AI agent would benefit from additional context like 'Use this when you need to record a credit from a vendor, not an expense or bill.'

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 states the deletion is permanent, describes the two-step preview-and-confirm flow, and notes that customers cannot be deleted. However, it does not mention potential error states, idempotency, or whether the tool is safe to retry.

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 compact: two sentences conveying purpose, supported types, usage flow, and an exclusion. No filler words. The important details are front-loaded.

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

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

For a tool with 3 parameters, no output schema, and moderate complexity (two-step delete), the description covers the essential workflow and constraints. It could optionally describe what the preview returns, but the basic completeness is strong.

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 across all 3 parameters. The description adds value by explaining the two-step flow's relationship to the confirm parameter and listing the allowed entity types, which enriches understanding beyond the enum 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 specifies a concrete verb-resource pair: 'permanently delete a QuickBooks transaction.' It lists supported entity types (journal entries, bills, etc.) and distinguishes from the sibling tool edit_customer by explicitly stating customers cannot be deleted and must be deactivated instead.

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 when-to-use guidance: for deleting specific transaction types. It also tells when not to use it (for customers) and offers an alternative (edit_customer with active=false). The two-step flow is clearly described.

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 discloses important behaviors: DepartmentRef is header-level only (lines don't support department), and line modifications (add, update, delete via line_id and delete flag). Also mentions draft mode for validation without saving. Lacks info on permanence or permissions.

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 two-sentence description focusing on core function and key details. Front-loaded with purpose, followed by essential behavioral notes. 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 9 parameters and no output schema, the description covers critical behaviors (line editing, department scoping, draft mode). Missing return value description, but overall adequate for a modification 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?

Adds significant value beyond schema: explains line modification logic (line_id for update, omit for add, delete=true to remove) and clarifies department scoping. All parameters have schema descriptions, but the description enhances understanding.

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

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

The description explicitly states 'Modify an existing bill' with specific updatable fields (vendor, date, due date, memo, lines). This clearly conveys the tool's function and distinguishes it from other edit tool 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?

No explicit guidance on when to use this tool versus alternatives like create_bill or delete_entity. The description implies 'edit an existing bill' but does not provide a clear when-to-use or when-not-to-use statement.

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 cover behavior. It mentions auto-resolution for parent_ref and sales_term_ref, and draft mode validation, but lacks details on authentication, error states, or side effects beyond deactivation.

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 efficiently deliver purpose and key behavior. No wasted words; front-loaded with the main action.

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

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

Given the tool's complexity (21 params, nested objects, no output schema), the description covers core functionality but omits return value, error handling, and validation details. Draft mode is explained, which helps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds a summary of updatable fields and clarifies active's deactivation effect, but mostly overlaps with 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 verb 'Modify' and the resource 'customer', listing specific fields. It distinguishes from siblings like create_customer and delete_entity, but could be more explicit about when to use this vs other edit tools.

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

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

The description provides some context (e.g., deactivation via active=false) but no explicit when-to-use or when-not-to-use guidance. It doesn't mention alternatives like delete+recreate or when to use draft mode.

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 fully discloses the critical merge behavior of the QB Deposit API: lines are merged, not replaced. It explains how to delete lines by setting amount to 0 and the total validation, providing comprehensive behavioral 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 concise and front-loaded with the action, followed by important behavioral caveats. It could benefit from bullet points for readability, but it efficiently conveys critical information without unnecessary verbosity.

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

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

Given 8 parameters, 100% schema coverage, and no output schema or annotations, the description covers purpose, line merge behavior, total validation, and draft parameter. It is complete for a modification tool, though omitting return value description is acceptable without 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 coverage is 100% with clear descriptions, but the tool description adds essential context beyond the schema, especially for the lines parameter and expected_total. It clarifies the merge logic and override scenario, which is not evident from 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 'Modify an existing deposit' and lists the updatable fields (date, memo, deposit account, department, lines), distinguishing it from sibling tools like create_deposit and get_deposit.

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

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

The description gives explicit guidance on line handling: how to update, add, and delete lines, and when to use expected_total for corrupted deposits. It lacks explicit when-not-to-use but provides sufficient context for correct invocation.

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 were provided; the description adds a key behavioral constraint that PaymentType cannot be changed after creation. It does not disclose other side effects, permissions, or whether updates are immediately saved, leaving some gaps.

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

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

Two concise sentences front-load the purpose and essential fields, with a one-line note about an important restriction. No wasted words.

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

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

For a tool with 9 parameters and no output schema or annotations, the description is brief. It covers the core purpose and a key constraint, but omits details about the 'draft' parameter's behavior, how lines are manipulated, and the result of saving. The high schema coverage partially compensates, but the description could be more 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 parameters. The description lists updatable categories (date, memo, etc.) but adds little extra meaning beyond the schema, meeting the baseline expectation.

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

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

Description explicitly states the verb 'Modify' and resource 'existing expense (Purchase)', and lists specific updatable fields. This clearly distinguishes it from sibling tools like create_expense or delete_entity.

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 indicates the tool is for modifying existing expenses and lists what can be updated, providing clear context. However, it does not explicitly state when to use versus alternatives like edit_bill or edit_invoice, though the resource name implicitly differentiates.

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 description carries full burden. Lists modifiable fields and line operations, but omits side effects (e.g., whether totals recalculate, permissions needed) and fails to clearly state that draft=true means no save (default behavior is preview only).

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

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

Two-sentence description is concise, front-loads purpose, and avoids redundancy. Each sentence adds distinct 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?

No output schema, but description does not mention return value or error handling. Covers main edit operations and line modifications, but missing key details about mutation effects and state changes.

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

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

Schema coverage is 100% (baseline 3). Description adds valuable context beyond schema for lines (update vs add vs delete) and draft behavior, justifying a higher score.

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

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

Clearly states 'Modify an existing invoice' and enumerates specific fields that can be updated. Differentiates from create_invoice and other edit tools by scope, but does not explicitly exclude using for other invoice types.

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 basic guidance for lines (update/add/delete) but lacks explicit when-to-use or when-not-to-use compared to siblings like edit_bill or create_invoice. No alternatives 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?

With no annotations, the description bears full burden. It reveals validation (debits=credits) and draft preview behavior. However, it omits details on mutation side effects, reversibility, or required permissions, leaving gaps for a full 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 brief (4 sentences), front-loads the main purpose, and structures instructions logically. 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 tool's complexity (nested lines, validation), the description covers key aspects: field updates, line CRUD, and draft validation. However, it lacks return value expectations or error scenarios, which is acceptable given no output schema.

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

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

The schema covers all parameters (100% coverage), but the description adds significant value by explaining line modification patterns (update via line_id, add via omission, delete via delete flag). This goes beyond schema descriptions.

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

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

The description clearly states the tool modifies an existing journal entry and lists updatable fields (date, memo, doc_number, lines). This distinguishes it from sibling tools like create_journal_entry (new) and get_journal_entry (read-only).

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 the description implies use when editing existing entries, it lacks explicit guidance on when not to use it or alternatives. Sibling context (e.g., create_journal_entry for new entries) provides some differentiation, but the description itself does not clarify.

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, but description covers line edit/add/delete logic and draft mode. Lacks info on idempotency, error handling, or full side effects, but adequate for 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?

Two efficient sentences: general purpose then line details. No fluff, key information front-loaded.

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

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

Covers main modifications adequately. Missing return value description and error conditions, but overall complete for a moderate-complexity tool with no 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 coverage is 100%. Description adds value by explaining line modification semantics (line_id, delete=true) and auto-resolution of item_name, going beyond schema descriptions.

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

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

Description clearly states 'Modify an existing sales receipt' with specific fields (date, memo, deposit account, department, lines), distinguishing it from create and other edit 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 explicit when-to-use or alternatives mentioned. Usage is implied by 'modify existing' but lacks guidance on choosing between edit and create or other edit tools.

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

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

With no annotations, the description carries the full burden. It discloses behaviors: lines can be added, updated, or deleted via specific fields; DepartmentRef is header-level only. It does not mention permissions or return values, but covers key behavioral aspects 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?

The description is concise with four sentences. It starts with the core purpose, then lists updatable fields, details line rules, and adds a constraint note. No redundant words; each sentence adds necessary 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 7 params and no output schema, the description explains input behavior well. It covers line item operations and a key constraint. Missing response details (e.g., success confirmation or updated object) but otherwise complete given the QBO context and sibling tools.

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

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

Schema coverage is 100% with descriptions. The description adds value beyond schema by providing line manipulation rules (requires amount and account_name for new lines, delete=true for removal) and a note about DepartmentRef constraint, which is not in the schema.

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

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

The description clearly states the action ('Modify an existing vendor credit') and the resource ('vendor credit'). It lists specific updatable fields (vendor, date, memo, ref number, and/or lines), distinguishing it from siblings like create_vendor_credit or get_vendor_credit.

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 (modify existing) but lacks explicit when-to-use or when-not-to-use guidance. It does not contrast with alternatives like create_vendor_credit or other edit tools, though it provides specific line manipulation rules.

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. Description lacks disclosure about read-only behavior, constraints, pagination, or caching. Only states it can be broken down, which is a feature not a behavioral trait.

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

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

Two concise sentences, front-loaded with purpose. No redundant words 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?

For a financial report tool with 4 parameters and no output schema or annotations, the description is too brief. It omits output details, default behaviors, prerequisites, and error conditions.

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

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

Schema coverage is 100%, so description adds minimal value. The sentence 'Can be broken down by department/location' adds context to the 'department' parameter, but does not elaborate on other parameters like summarize_by or accounting_method.

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?

Clear verb+resource: 'Get a Balance Sheet report.' Distinguishes from siblings like get_profit_loss by mentioning breakdown by department/location.

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

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

No explicit when-to-use or alternatives. Only implies usage for balance sheet reports, but no guidance on when to prefer this over other reports or when not to use.

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

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

Discloses key behavioral trait: returns SyncToken for edits. Lists returned fields (vendor, date, etc.). No annotations, so description carries full burden; adequately transparent for a read operation.

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

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

Two sentences, no wasted words, action first. Ideal conciseness.

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

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

Given no output schema, description adequately specifies return fields. Lacks error handling or edge cases, but sufficient for a simple fetcher.

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

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

Schema already describes 'id' as 'The bill ID' (100% coverage). Description adds no additional meaning beyond 'by ID', so baseline 3.

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

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

The description clearly states the tool fetches a single bill by ID with full details, distinguishing it from list or query tools. Verb 'fetch' and resource 'bill' are specific.

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

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

Implies usage before editing ('needed for edits'), but does not explicitly state when to use this over alternatives like query or list. No when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses what fields are returned (vendor, date, pay type, etc.) and mentions flagging unapplied amounts, but does not cover side effects, permissions, or idempotency.

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 front-loads the main action and key detail (SyncToken), and the second lists contents concisely.

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 fetch tool with one parameter and no output schema, the description adequately covers what is returned. Minor omission: no mention of error cases or behavior when ID not found, but overall sufficient.

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

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

Schema coverage is 100% for the single parameter 'id', and the description adds no additional meaning beyond what the schema already provides ('the bill payment ID'). 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 'Fetch a single bill payment by ID with full details including SyncToken', specifying the verb, resource, and scope. It distinguishes from siblings like 'get_bill' by focusing on payments.

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 fetching a specific bill payment by ID but provides no explicit guidance on when to use it vs. alternatives, no when-not-to-use scenarios, and no context about 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?

No annotations are provided, so the description carries full burden. It indicates a read operation but lacks details on what information is returned, auth requirements, or any rate limits. The description is minimal and does not disclose behavioral traits.

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

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

The description is a single, front-loaded sentence with no superfluous words. Every word contributes to the meaning.

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

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

Given no output schema and no parameters, the description is adequate but could mention the type of information returned (e.g., company name, address). It leaves the agent guessing about the output structure, which is a minor gap.

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

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

The tool has zero parameters, and schema coverage is 100% (vacuously). The description adds a slight semantic cue by specifying 'connected QuickBooks company,' implying no parameterization is needed. This is sufficient for a parameterless tool.

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

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

The description clearly states the verb "Get" and the resource "information about the connected QuickBooks company." It distinguishes from sibling tools like `get_bill` or `get_customer` by targeting general company info rather than a specific entity.

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 top-level company details, but provides no explicit guidance on when to use this tool versus alternatives like `query` or `list_accounts`. No exclusions or context are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It accurately describes the read-only nature (Fetch) and specifies the fields returned. It includes the important behavioral detail that SyncToken is required for edits, adding value beyond a simple 'get' statement.

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

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

The description is a single sentence that packs essential information: purpose, return details, and a key usage hint. It is concise and front-loaded with the main action. Minor improvement could be splitting into two sentences for readability, but it is effective.

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

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

For a simple get-by-ID tool with one parameter and no output schema, the description sufficiently covers the return values and hints at the editing workflow. It does not mention error handling or authentication, but given the tool's simplicity, it is adequately complete.

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

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

The input schema covers 100% of parameters with a description for 'id'. The description adds meaning by stating 'Fetch a single customer by ID', reinforcing that the ID identifies a customer, and mentions that the response includes SyncToken, which is relevant to the id's use in subsequent edits.

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 'Fetch a single customer by ID', specifying the verb and resource. It distinguishes from sibling tools like list_accounts or query, and from other get_* tools by mentioning customer-specific details like SyncToken, hierarchy, and balance.

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 notes that the returned SyncToken is 'needed for edits', which implies that this tool should be called before edit_customer. It provides clear context for when to use the tool, though it does not explicitly mention when not to use it or alternatives.

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

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

No annotations provided, but description adds behavioral context by mentioning SyncToken needed for edits and listing returned fields. Lacks disclosure of error handling or authorization requirements, though these are less critical for a read operation.

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

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

Single, well-structured sentence front-loads the action and packs essential information without wasted words.

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

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

Given one parameter, no output schema, and no annotations, the description adequately covers what the tool does and returns. It provides complete context for a simple fetch operation.

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

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

Schema coverage is 100% with basic 'id' description. Description adds purpose (fetch deposit details) but does not provide additional semantic meaning beyond schema.

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

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

Description clearly states 'Fetch a single deposit by ID' with specific verb and resource. It lists return details (deposit account, date, memo, line details) and distinguishes from sibling tools that list or query various 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?

Description implies usage for retrieving deposit details and obtaining SyncToken for edits, providing clear context. However, it lacks explicit when-not-to-use 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?

No annotations are provided. The description uses 'Fetch' implying a read operation but does not confirm read-only behavior, mention error handling, permissions, or side effects. For a tool with no annotations, more transparency is needed.

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 at two sentences, front-loading the main purpose. It could be slightly better structured but is not 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?

The description specifies what is returned (payment type, account, date, amount, line details) and the types covered (Expenses, Checks, Credit Card charges). Although no output schema exists, the description provides a reasonable overview. Could be improved by clarifying differences from similar fetch tools.

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

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

Schema coverage is 100% with a single parameter 'id' described as 'The expense (Purchase) ID'. The description adds no additional meaning beyond 'by ID', so baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Fetch'), the resource ('a single expense (Purchase)'), and the scope ('Covers Expenses, Checks, and Credit Card charges'). It also lists what is returned, distinguishing it from sibling tools like get_bill or get_deposit.

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 a single expense by ID, but does not explicitly state when to use versus siblings (e.g., get_bill for bills). No 'when not to use' or alternative tools 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 provided, so description carries burden. It correctly implies read-only operation but does not explicitly state non-destructive behavior or potential errors.

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

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

Two sentences, front-loaded with main action and key detail (SyncToken), then lists returned fields. 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?

Only one parameter and no output schema; description is sufficient, listing key return data. Could mention edge cases (e.g., 404).

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 100%; description adds 'by ID' but no extra meaning beyond what schema already provides.

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

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

The description clearly states it fetches a single invoice by ID, lists returned fields, and distinguishes from siblings like edit_invoice by noting SyncToken is needed for edits.

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 use before edit_invoice by highlighting SyncToken. Could explicitly contrast with query for listing, but context is clear for this simple fetch.

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 discloses the side effect of writing to a temp file and the return of a formatted summary. This adds useful behavioral context beyond a simple fetch.

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

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

Two concise sentences with key information front-loaded. 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?

For a simple get tool with one parameter and no output schema, the description covers return details (formatted summary and temp file write). Could mention error behavior but is sufficient.

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

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

Schema coverage is 100% with a single parameter 'id' described as 'The journal entry ID'. The description adds no extra semantics but is consistent with the schema.

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

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

The description clearly states the tool fetches a single journal entry by ID, providing full details including SyncToken. It specifies the resource and action, distinguishing it from sibling tools like list or create.

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 indicates usage for edits by mentioning SyncToken is needed for edits. However, it does not explicitly exclude other use cases or compare with alternatives like query.

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 only notes the ability to break down by department/location, which is a behavioral trait. However, it does not disclose that the tool is likely read-only, safe, or any other behavioral aspects (e.g., no side effects, authentication needs). This is insufficient for a report tool where agents need to know it is a query operation.

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

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

The description is extremely concise at two sentences. The first sentence states the core purpose, and the second adds an optional capability. There is no redundant information, and every word serves a purpose. It is 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 has no output schema and no annotations, the description provides minimal context. It does not explain the report format, that it is read-only, or what to expect in the response. For a financial report tool, agents need more context to use it correctly, especially since it lacks structured metadata.

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

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

The input schema already documents all five parameters with clear descriptions, achieving 100% coverage. The description adds minimal value, merely hinting at the department parameter by mentioning breakdown. The parameter semantics are adequately covered by the schema, so the description does not need to compensate significantly.

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

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

The description clearly states that the tool retrieves a Profit and Loss report, which is a standard financial statement. The mention of breakdown by department/location adds specificity, distinguishing it from generic report tools. However, it does not explicitly differentiate from sibling tools like get_balance_sheet or get_trial_balance, though the resource name is clear.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_balance_sheet or get_trial_balance. There is no mention of prerequisites, context, or conditions. The description merely states what it does, leaving the agent to infer usage from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns full details including the SyncToken necessary for edits, and lists the return fields (customer, date, deposit account, department, line details). This is good transparency about the tool's behavior, though it does not mention potential errors or permissions.

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, with two sentences. The first sentence states the action and key detail (SyncToken for edits). The second lists what is returned. Every word earns its place, and it is front-loaded with the primary 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 simplicity of the tool (one parameter, no output schema), the description is fairly complete. It explains what the tool does and what it returns. It could mention that the ID is required and must be valid, but overall it provides sufficient context for a straightforward fetch operation.

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

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

The input schema has only one parameter 'id' with a basic description. The description adds context by stating the ID is needed for fetching and that SyncToken is included for edits. However, with 100% schema coverage, the description adds minimal value beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool fetches a single sales receipt by ID, specifying the verb and resource. It distinguishes from sibling tools like create_sales_receipt and edit_sales_receipt by focusing on retrieval. Mentioning 'SyncToken needed for edits' provides additional context.

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 viewing or preparing to edit a sales receipt but does not explicitly differentiate when to use this tool over other similar get_* tools or provide alternative suggestions. The context is clear but lacks explicit guidance on 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 carry the full burden of behavioral disclosure. It mentions a limitation (no department/location breakdown) but does not describe the return format, data freshness, or other behavioral aspects. The description adds some value but lacks comprehensive 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 highly concise with two sentences and a note, all front-loaded with essential information. No redundancy or wasted words.

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

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

Given the simple schema (3 string parameters, no enums, no output schema), the description is fairly complete. It covers use cases and a key limitation. However, it could mention default behavior for empty dates or result handling to be fully 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?

All three parameters (start_date, end_date, accounting_method) have clear descriptions in the input schema. The tool description adds no additional meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states 'Get a Trial Balance report' and provides context about its usefulness for month-end close and reconciliation. However, it does not explicitly distinguish this tool from sibling report tools like get_balance_sheet or get_profit_loss, which share similar use cases.

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 specifies when to use the tool ('month-end close and reconciliation') and includes an important limitation (no department/location breakdown in QuickBooks Online). While it gives good context, it lacks explicit guidance on when not to use it or alternative 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?

No annotations are provided, so the description must disclose behavior. It fully describes what is returned (SyncToken, vendor, date, etc.). It does not explicitly state it is a safe read-only operation, but the verb 'Fetch' implies no side effects.

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 lists the tool's function and output components with no extraneous 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 fetch-by-ID tool with no output schema, the description adequately covers what the tool returns. It could mention that only one record is returned, but this is implied. Missing details like error handling are acceptable for this simplicity.

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

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

The only parameter 'id' is described in the schema as 'The vendor credit ID'. The description adds 'by ID' but provides no additional semantics beyond what the schema already provides. With 100% schema coverage, baseline is 3.

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

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

The description clearly states 'Fetch a single vendor credit by ID with full details including SyncToken (needed for edits)'. It specifies the verb 'Fetch', the resource 'vendor credit', and distinguishes from siblings like edit_vendor_credit by mentioning SyncToken for edits.

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 before editing by noting 'SyncToken (needed for edits)'. It does not explicitly state when not to use or provide alternatives, but given the context of sibling tools, the purpose is clear.

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

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

No annotations are provided, so the description must carry full burden. It states the tool returns fields but does not disclose any behavioral traits such as pagination, rate limits, or authorization requirements. It implies a read operation 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 two concise sentences with no waste. The first sentence states the core purpose, and the second provides actionable guidance. Every sentence earns its place.

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

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

Given no output schema, the description adequately explains return fields and usage. However, it lacks details on pagination or default behavior (e.g., account ordering). Still, it is sufficient 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 covers both parameters with descriptions (100% coverage), so baseline is 3. The description adds value by mentioning the specific returned fields and advising to use AcctNum for referencing, enhancing parameter understanding.

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

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

The description clearly states the verb 'List' and the resource 'all accounts in the chart of accounts', which is specific and distinct from sibling tools that deal with creation, editing, or other reports.

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

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

The description indicates when to use the tool (to get account numbers for further operations) but does not explicitly state when not to use or compare to alternatives like 'query' or 'account_period_summary'. However, the context is clear enough.

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 description carries full burden. It discloses two-step process, browser interaction, and mode restriction. Lacks explicit mention of return values (e.g., whether it returns success or token).

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

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

Three sentences, front-loaded with purpose, no wasted words. Each sentence adds necessary 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 no annotations and no output schema, the description covers process, parameters, and restrictions well. Could improve by stating output of each step, but still adequate 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 covers 100% of parameters with descriptions. The description adds value by explaining the sequential usage and where to obtain the parameter values from the callback URL.

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 tool authenticates with QuickBooks via OAuth, with a specific two-step process. No sibling tool does authentication, so distinct.

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

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

Explicitly describes the two-step call sequence: first with no arguments to get authorization URL, second with authorization_code and realm_id from callback. Also states the credential mode restriction.

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 that results are written to a file, default MAXRESULTS is 1000, most transaction fields are not filterable, and error responses include valid filterable fields. This is valuable behavioral context, though it could mention if the operation is read-only.

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

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

The description is concise (three sentences plus an example) with no wasted words. It front-loads the action and resource, provides examples, and includes important constraints. Every 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?

Given the tool's simplicity (one parameter, no output schema), the description covers all necessary aspects: what it does, how to use it, defaults, limitations, and error handling. It is complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds the file-writing behavior and the hint about using 'query_account_transactions' for filtering, which adds value beyond the schema. However, the schema already covers entity types and MAXRESULTS, so the added value is moderate.

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 'Execute a QuickBooks query' and the resource 'using SQL-like syntax'. It lists supported entity types and provides examples. It also distinguishes from the sibling tool 'query_account_transactions' by directing account/department filtering there.

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 provides when to use (any entity type) and when not to (account/department filtering, directing to 'query_account_transactions'). Also mentions default MAXRESULTS and the note about non-filterable fields, guiding the agent on query construction.

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 full responsibility. It discloses that the tool searches across multiple transaction types and returns a consolidated list with specific fields. However, it lacks details on pagination, performance, or potential errors, which are important for a query 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 concise with three sentences, front-loading the purpose and providing key details. 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 output schema, the description explains the return values (date, type, amount, description). It covers the complexity of searching across multiple transaction types. However, it omits information about pagination, limits, or sorting, which are relevant for a query tool but 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?

Schema coverage is 100%, so the baseline is 3. The description adds context by mentioning the transaction types searched, which indirectly relates to the `account` parameter, but does not provide additional semantic meaning beyond what the schema already offers. No extra parameter details 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 it queries all transactions affecting a specific account, lists the transaction types covered (JournalEntry, Purchase, etc.), and specifies the returned fields (date, type, amount). This distinguishes it from sibling tools like `get_bill` (single entity retrieval) or `list_accounts` (listing 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 indicates it is 'useful for investigating account balance discrepancies', providing clear context for when to use it. It does not explicitly state exclusions or alternatives, but the sibling context shows many `get_*` tools for individual transactions, making the use case clear.

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