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

The description gives no information about side effects, data modifications, authentication requirements, or whether this is a create operation. With no annotations, the description alone fails to disclose any behavioral implications of invoking this 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 but overly sparse—two short sentences without structured details. It conveys minimal information and does not organize any usage context or parameter hints, failing to be usefully structured.

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

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

For a tool with seven parameters and three required fields, this description is severely incomplete. It lacks parameter explanations, usage scenarios, and any relationship to other tools, leaving the agent without sufficient context 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?

The description does not explain any of the seven parameters (name, balance, apr, etc.). The schema lacks descriptions, so the agent has no guidance on what each parameter means or how to fill them correctly.

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

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

The description states that the tool tracks a debt not linked to a Plaid account, and the tool name 'add_external_debt_tool' clarifies it is for adding external debts. However, the phrasing 'isn't behind a linked Plaid account' is slightly awkward and could be clearer, preventing a perfect score.

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

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

The description implies usage for non-Plaid debts but does not explicitly distinguish from sibling tools like 'link_account' or 'get_liabilities_tool'. No conditions, prerequisites, or when-not-to-use guidance is provided, leaving the agent to infer when this tool is appropriate.

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

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

With no annotations, the description carries the burden of explaining behavioral impact. It states the removal action but does not mention whether the operation is irreversible, requires special permissions, or affects account data beyond the APR override.

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, containing only two short sentences with no redundant information. The core action and a platform qualifier are presented efficiently.

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

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

For a simple single-parameter mutating tool with no output schema, the description covers the essential purpose and platform scope. It lacks behavioral detail, but the overall context is reasonably complete.

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

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

The schema only provides 'account_id' as a required string with no description. The description ties the parameter loosely to 'an account' but does not clarify the expected ID format, scope, or whether it refers to a Plaid account ID.

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

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

The description clearly states the action ('Remove any APR override') and the target ('for an account'), distinguishing it from related tools like set_account_override_tool and list_overrides_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 'Plaid-only' note provides a platform restriction, but there is no explicit guidance on when to use this tool versus setting or listing overrides. Usage must be inferred from the tool name and sibling context.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals the token exchange and account caching side effects, which is useful, but it does not explain idempotency, failure behavior, or what 'caches accounts' means operationally.

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 and front-loaded with the primary action, then the mechanism, then the scope qualifier. Every sentence adds value with no redundancy.

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

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

The tool has no annotations, no output schema, and zero schema description coverage. The description conveys the core action but omits parameter semantics, expected response, and operational caveats, leaving an agent without enough detail to invoke it confidently in edge cases.

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

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

Schema description coverage is 0%, and the description does not explain link_token or timeout_seconds. link_token is inferable from context, but timeout_seconds is entirely unexplained, and the description mentions public_token rather than the actual parameter name.

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 finalizes a Link session, exchanges public_token for access_token, and caches accounts. It uses a specific verb and resource, and is distinguishable from siblings like link_account which starts the flow.

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 says to use this once the user has completed Link in their browser, giving clear timing context. It does not name alternatives or exclusions, but the intended point in the flow is unambiguous.

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. 'Lookup' implies a read-only operation, but the description does not explicitly state that there are no side effects, permissions required, or other behavioral traits. It is not misleading, but lacks explicit 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 a single concise sentence with no redundant information. It uses clear, direct language and is efficiently structured for quick comprehension.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema (not shown but indicated as true), the description is largely sufficient. It covers the core purpose and the only parameter. It does not mention edge cases or result format, but that falls under the output schema's responsibility.

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

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

The description adds meaning to the sole parameter `account_id` by explaining it is a filter and optional ('if given'). This is beyond the schema's type and default, compensating for the 0% schema description coverage. It does not elaborate on the semantics of the account_id value itself, but that is inferable from the domain.

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 'Live balance lookup' clearly states the tool's function (retrieve balances) and the optional filter by account_id. It is distinguishable from sibling tools like get_liabilities_tool or get_holdings_tool, though 'lookup' is slightly less explicit than 'get' or 'retrieve'.

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

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

The description provides minimal guidance on when to use this tool versus alternatives. It mentions 'Live' implying real-time data, but does not explicitly contrast with other balance-related tools or state conditions for selection. No usage scenarios 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, the description carries the behavioral burden. It discloses that this is a Plaid-only read of current positions and lists return contents, but it does not explain optional account_id behavior, whether data is cached, or any authentication/linking requirements beyond the Plaid constraint.

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 and front-loaded: the first sentence states what the tool returns, and the second gives the critical provider limitation. No words are wasted.

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

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

The description is adequate for selecting the tool and understanding its return fields, but it is incomplete for correct invocation because it does not explain the optional account_id parameter or the effect of passing null. Since there is no output schema, a bit more detail on filtering behavior would be valuable.

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

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

Schema description coverage is 0%, and the description does not mention account_id at all. The parameter name is somewhat self-explanatory, but the description fails to clarify whether omitting it returns all holdings or requires an account, so the agent lacks important invocation semantics.

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

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

The description clearly identifies the resource as current investment positions and lists the key fields returned (tickers, quantities, market value, cost basis). It does not explicitly distinguish itself from siblings like get_investment_transactions_tool, but 'positions' vs 'transactions' is reasonably 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?

The description gives explicit provider guidance: 'Plaid-only — Teller has no INVESTMENTS capability.' This tells the agent when the tool is applicable and when it is not, though it does not name alternative sibling tools for investment transactions.

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

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

Annotations are absent, so the description must carry the full burden of behavioral disclosure. It conveys only a static list of data fields and the phrase 'as reported by the institution'—this hints at provenance but says nothing about whether the operation is purely read-only, the impact of omitting account_id, failure conditions, or rate limits.

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

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

The description is short and free of filler, but it is a noun phrase fragment rather than a structured sentence. It lacks an ordering that leads the agent through what the tool returns and any conditions, so the brevity is more under-specification than efficient concision.

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?

There are no annotations, no output schema, and one optional parameter, so the description carries nearly all context. It fails to explain the output structure, what happens when account_id is null, and how this tool fits with sibling tools like list_linked_institutions or list_accounts. An agent would be uncertain about return shapes and parameter behavior.

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

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

The input schema has one parameter, account_id, with 0% coverage in the description. The description does not explain what account_id does—whether it filters to a single account, is required for any specific institution, or can be null to get all accounts. The tool description provides no compensation for the missing parameter meaning.

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 identifies the resource and specific data fields (names, emails, phones, addresses) without ambiguously matching sibling tools. It lacks an explicit verb, but the subject matter clearly indicates a retrieval operation for account-holder identity data.

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

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

No guidance is given on when to call this tool versus siblings like list_accounts_tool or get_income_tool, nor any mention of prerequisites such as a linked institution or authorization. An agent cannot tell the intended conditions for using this tool from the description alone.

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

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

With no annotations, the description carries the disclosure burden. It adds meaningful context about the Plaid-only restriction and the product requirement, which are important behavioral constraints. However, it does not mention error behavior, return structure, or what happens if the product is not enabled.

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 short sentences, with the core purpose front-loaded and the prerequisite/limitation stated immediately after. Every sentence earns its place with no redundant filler.

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

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

Given the tool's simplicity, zero parameters, and absence of an output schema, the description is mostly complete for selection and invocation. It provides the key prerequisites and platform limitation, though it could have briefly stated that the return value is a list of income streams.

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

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

The tool has zero parameters, so the empty schema fully documents the calling contract. The description adds no parameter information, but none is needed; the baseline for a no-parameter tool is appropriate here.

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

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

The description clearly identifies the resource as 'bank-detected income streams' and the tool name supplies the 'get' verb, making the purpose unambiguous. It also distinguishes itself from sibling tools by domain, though it does not explicitly compare against them.

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

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

The description states the prerequisite of the Income product being enabled and explicitly restricts the tool to Plaid, noting Teller lacks INCOME capability. This gives clear context for when the tool is usable, though it does not discuss when to prefer it over alternative data sources.

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 behavioral burden, but it does not disclose side effects, read-only guarantees, pagination, data freshness, or error behavior. The short phrase only describes the content category, not how the tool behaves.

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 and front-loads the core purpose and the key platform constraint. It avoids fluff, though the first line is a sentence fragment rather than a complete verb phrase.

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 lacks essential invocation context: no return shape, no date-format guidance, no account-scoping semantics, and no explanation of how this differs operationally from sibling transaction tools. The Plaid-only note is useful but insufficient for reliable use.

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

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

The schema has no parameter descriptions and the description adds no meaning to start_date, end_date, account_id, or limit. It does not mention date formats, whether account_id is required for certain providers, or how limit is applied, leaving the agent to guess.

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 identifies the resource as brokerage transactions and enumerates the relevant transaction kinds (buys, sells, dividends, fees). It also distinguishes this tool from generic transaction tools by the investment focus and the Plaid-only constraint.

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

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

It states a concrete platform limitation: Plaid-only, and that Teller has no INVESTMENTS capability. However, it does not explicitly direct the agent to prefer this tool over get_transactions_tool or search_transactions_tool for investment-related calls.

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 behavioral disclosure burden. It does reveal a meaningful platform limitation (Plaid-only, Teller unsupported), but it does not mention side effects, failure behavior for unsupported connections, or whether a linked account is required.

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 tight sentences with no filler. The core content is front-loaded, and the platform constraint is stated efficiently in the second sentence.

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

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

For a zero-parameter read tool, the description is mostly complete: it names the data returned and the key platform limitation. The main gap is that, with no output schema and no annotations, an agent must infer the exact return shape and error behavior for unsupported providers.

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

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

The tool has zero parameters and the schema already covers this completely, so there is nothing for the description to add about inputs. The description appropriately focuses on what data will be returned.

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 identifies the resource as liabilities and enumerates the included data (APRs, balances, due dates), which pairs clearly with the 'get' verb in the tool name. It is distinct from sibling tools like get_balances_tool or get_holdings_tool, though it does not explicitly state an action such as 'Retrieves...'.

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?

There is no explicit when-to-use guidance or named alternative. The 'Plaid-only — Teller has no LIABILITIES capability' note implies a constraint, but it does not tell an agent when to prefer this tool over related siblings like list_accounts_tool, get_balances_tool, or summarize_debt_tool.

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

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

With no annotations, the description carries the behavioral burden and covers meaningful traits: data source (local cache vs live API), a required prerequisite for Plaid, and the sign convention 'Positive amounts = spend.' It does not describe pagination or output ordering, but the output schema exists to cover return structure.

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

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

Four short sentences with no filler: the main action is front-loaded, then provider behavior, prerequisite, and sign convention each earn their place.

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

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

Given the output schema exists and the required parameters are simple, the description is reasonably complete: it covers date format, provider-specific data freshness, and the sync prerequisite. It could be more complete by naming search_transactions_tool as the alternative for advanced filtering, but this is not a blocking gap.

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

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

Schema description coverage is 0%, and the description only compensates for the date format and amount sign interpretation. The remaining optional filters (limit, category, merchant, account_id) are left to their self-explanatory names and schema defaults, so the compensation is partial.

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

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

The description opens with a specific verb and resource: 'Query transactions between two dates,' and specifies the date format. It is clear, though it does not explicitly distinguish itself from sibling search_transactions_tool or spending_summary_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?

It gives provider-specific usage context: for Plaid, 'run sync_transactions first' because it reads the local cache, while Teller fetches live. However, it never states when to choose this tool over sibling alternatives or mentions exclusions.

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

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

With no annotations, the description carries the full burden. It clearly explains the flow: starts a session, returns a URL, and requires a follow-up call. It does not mention edge cases like cancellation or errors, but the core behavior is transparent enough for an agent to understand the tool's role.

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

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

The description is concise, using two clear sentences and a brief note. It is well-structured, leading with the action, then the return value, then the follow-up, and finally the alternative command. No 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?

Without an output schema, the description effectively covers the essential context: what the tool returns (a URL), how the agent should proceed (call complete_linking), and the provider-specific alternative. This is 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?

The input schema is empty, so there are no parameters to describe. The description adds no parameter-related meaning beyond what the schema already conveys (trivially complete). Baseline of 3 is appropriate since no additional parameter context is needed.

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

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

The description clearly states the tool's purpose: to start a Plaid Link session, return a URL for user authentication, and then instruct to call complete_linking. It also explicitly differentiates from the teller provider alternative, making it distinct from sibling 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?

It provides explicit when-to-use and when-not-to-use guidance: use for Plaid provider, and under PROVIDER=teller run 'plaid-mcp teller connect' instead. It also describes the follow-up step to complete_linking, giving complete usage context.

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

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

There are no annotations, so the description carries the burden of conveying behavior. 'List every account across every linked institution' transparently signals a global, unfiltered read operation, but it does not disclose details like pagination, performance, or authentication side effects. The output schema covers return shape.

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, tight sentence with no filler. The action and scope are front-loaded, and 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?

For a zero-parameter list tool with an output schema, the description is nearly complete: it names the resource and the full scope. It does not explicitly call out sibling distinctions or read-only behavior, but those are largely inferable from 'list' and 'every account'.

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

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

The tool has zero parameters and the input schema is empty, so there is nothing for the description to explain. The baseline for zero-parameter tools is 4, and the description appropriately avoids inventing parameter details.

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

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

The description states a specific verb ('List'), a precise resource ('every account'), and a clear scope ('across every linked institution'). This clearly differentiates it from siblings like list_linked_institutions_tool, which lists institutions rather than accounts.

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

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

The description implies the main use case: retrieving the complete set of accounts across all linked institutions. However, it does not explicitly mention alternatives or say when not to use this tool, such as when only balances or institutions are needed.

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

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

Since no annotations are present, the description carries full responsibility for disclosing side effects. While 'List' implies a read-only operation, the description does not explicitly state that no data is modified, nor does it mention any potential changes to state or data. This lack of explicit transparency lowers the score.

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

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

The description is extremely concise and to the point: a single clear sentence followed by a short note. It avoids unnecessary details and is well-structured for quick understanding.

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

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

The description covers the essential function and scope, and given the absence of parameters and output schema, it is nearly complete. However, the 'Plaid-only' note is unexplained and could leave the agent uncertain about platform constraints, slightly reducing completeness.

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

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

The tool has zero parameters, so schema coverage is 100% (vacuously). The description has no need to explain parameters. Per the rubric, with high schema coverage, the baseline score 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 the tool's purpose with a specific verb ('List') and a precise resource ('external (non-Plaid-linked) debt'). The qualifier 'external (non-Plaid-linked)' effectively distinguishes it from sibling tools like get_liabilities_tool or summarize_debt_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 the core function but offers no explicit guidance on when to choose this tool over alternatives. The 'Plaid-only' note is ambiguous and could be interpreted as a restriction, but it is not explained as a usage condition. No alternative actions or decision heuristics are mentioned.

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

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

With no annotations, the description carries the burden. It explicitly says 'reads', indicating a read-only operation with no side effects, and describes the data source (local SQLite items table). It does not mention side effects or costs, but for a read tool this is sufficient.

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

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

The description is two sentences: one for purpose and one for context. There is no redundancy or extraneous detail, making it appropriately concise.

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

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

The description provides enough context for usage: what it does, the data source, and the Plaid scope. The output schema is present (not shown but indicated), so details about return values are covered there. It could mention what constitutes an 'institution' but that is not critical.

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

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

The input schema has no parameters (properties empty), so there is nothing to describe. The description accurately reflects that it lists all institutions without filters, making parameter explanations unnecessary.

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 'every institution currently linked', with account counts and errors. It also distinguishes itself by noting it is Plaid-only, which sets it apart from sibling 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 gives a clear 'when to use' by stating it is Plaid-only and reads the local SQLite items table, implying it is appropriate for Plaid-linked institutions. It does not explicitly name alternatives but the scope is understood from the Plaid-versus-Teller context.

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

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

The description implies a read-only operation by using 'List', but it does not explicitly state that no data is modified, nor does it mention permissions or side effects. Since there are no annotations, the description carries the burden, and the implication is not fully disclosed.

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

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

The description is extremely concise and free of fluff. It conveys the exact purpose and a scope constraint ('Plaid-only') in two short sentences, with 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?

For a simple list tool, the description is complete. It identifies what is listed (account APR overrides) and the context (user-recorded, Plaid-only). No output schema exists, so no return format explanation is required. It provides enough 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?

With zero parameters, the baseline is 4. The description adds meaning about the subject (account APR overrides), but since there are no parameters to explain, it does not go beyond the baseline in terms of parameter-specific semantics.

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

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

Clearly states the tool lists account APR overrides, distinguishing it from sibling tools like set_account_override_tool or clear_account_override_tool. The verb 'List' and resource 'account APR override' are explicit.

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?

Does not provide explicit guidance on when to use this tool versus alternatives. It mentions 'Plaid-only' as a scope constraint but does not explain scenarios for using it (e.g., before setting an override). No comparison to other list tools is offered.

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

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

No annotations. The description hints at an action but does not disclose whether the refresh is synchronous, modifies stored data, has rate limits, or how failures are surfaced.

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

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

Two short sentences with no filler or redundant wording.

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

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

Even for a simple schema, the description omits item_id semantics, return/acknowledgment behavior, async vs sync execution, and error cases, so an agent cannot call it confidently.

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, item_id, has no description in the schema or the tool description. Its optionality and default null are unexplained, leaving meaning entirely ambiguous.

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?

States the action (pull fresh transactions) and the context (Plaid, bank, immediate). Differentiates from get/search tools via the refresh intent, though 'nudge' is informal and 'Plaid-only' is vague.

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?

Only constraint is 'Plaid-only'. No explicit guidance on when to use this tool versus siblings like sync_transactions_tool, or when refresh is appropriate.

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

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

The description implies a destructive operation but does not disclose side effects, irreversibility, or any required permissions. With no annotations, the description carries the burden and only partially addresses it.

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

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

The description is extremely concise, with no redundant words. The action and resource are front-loaded, and the extra 'Plaid-only' note is brief but potentially useful.

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

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

For a simple deletion tool, the description is minimally sufficient, but it omits any mention of return values, success/failure behavior, or edge cases. It is adequate but not complete.

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

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

The parameter 'debt_id' has no schema description and the tool description does not explain its format, origin, or how to obtain it. Schema coverage is 0%, and the description does not compensate.

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

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

The description clearly states the action ('Delete') and the resource ('an external debt entry'), distinguishing it from sibling tools like add, update, list, and summarize debt. The purpose is immediately obvious.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as update_external_debt_tool or clear_account_override_tool. The 'Plaid-only' note is a constraint but not a usage condition.

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 behavioral disclosure burden. It explicitly states that local data is deleted, which is an important destructive side effect beyond simply 'unlinking.' It does not mention reversibility or permissions, but the main risk is disclosed.

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

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

The description is compact, front-loaded with the primary action, and adds the important destructive detail in the same sentence. The standalone 'Plaid-only.' line is minimal but useful context with no wasted words.

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

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

For a simple one-parameter destructive tool, the description conveys the core action and side effect. However, it omits any explanation of item_id provenance or expected format, and offers no guidance on what happens after unlinking or what response to expect.

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

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

The input schema has 0% description coverage, and the description does not explicitly explain the item_id parameter. However, the description's mention of 'Plaid item' and the parameter name 'item_id' make it reasonably inferable that item_id identifies the institution to unlink.

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

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

The description uses a specific verb ('Unlink') and resource ('institution (Plaid item)'), and adds a concrete consequence ('delete its local data'). This clearly identifies what the tool does and distinguishes it from sibling tools like link_account or remove_external_debt_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 phrase 'Plaid-only' provides a constraint on when the tool applies, and the action itself implies it is for unlinking a linked institution. However, there is no explicit guidance about when not to use it or which alternative to choose, such as remove_external_debt_tool for non-Plaid debts.

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?

There are no annotations to communicate side effects, read-only behavior, or access requirements. The description merely states what the search does and does not disclose whether it mutates data, requires authentication, or has rate limits.

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

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

The description is a single, focused sentence with no redundant information. It states the core functionality clearly and efficiently.

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

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

Given the four parameters, the description leaves out important context such as how date filtering works, what the limit controls, and what the result set contains. It is minimal but not sufficient for an agent to fully understand the tool's behavior.

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

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

The schema provides no descriptions for the parameters, and the tool description does not explain the meaning of query, limit, start_date, or end_date. Since schema coverage is 0%, the description must compensate, but it entirely fails to do so.

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

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

The description clearly identifies the action (fuzzy search) and the resource (transactions), narrowing the scope to description and merchant name. It does not explicitly differentiate itself from sibling tools like get_transactions_tool, but the 'fuzzy search' wording provides enough distinction.

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

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

No explicit guidance is given for when to use this tool versus alternatives such as get_transactions_tool. The use case is only implied by the phrase 'fuzzy search,' which is not enough to guide an agent effectively.

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

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

No annotations are provided, and the description only states intent; it does not disclose whether existing overrides are replaced, how nullable fields behave, persistence, or failure modes.

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

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

Two short sentences with no filler; the key purpose and restriction are front-loaded and easy to parse.

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

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

Missing parameter meanings, output/return behavior, side effects, and relationship to clear/list override tools; only the 'Plaid-only' context is provided.

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

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

Schema coverage is 0%, and the description only hints at effective_apr; account_id, note, and promo_expires semantics are not explained.

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?

States it annotates a linked card with the real APR when Plaid misses it; specific and distinguishes from clear/list overrides, though 'annotate' is less precise than 'set/override'.

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

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

Provides a condition ('when Plaid misses it') and a 'Plaid-only' restriction, but does not explicitly contrast with clear_account_override_tool/list_overrides_tool or say 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?

The description indicates the tool is read-only ('reads the Plaid-shaped cache') and depends on prior syncing, but it does not disclose error behavior, data freshness, or whether it returns aggregated results directly or requires post-processing. This is partial transparency, not comprehensive.

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

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

The description is concise, using two short sentences that quickly convey the core function and data source. The pipe-separated grouping options are a compact way to list alternatives, though slightly informal.

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 3 parameters and an output schema, the description is incomplete: it does not explain parameter constraints, output structure, or how this tool relates to sibling tools like sync_transactions_tool. The mention of 'Plaid-only' and cache adds some context, but not enough for a new agent to use it effectively without additional investigation.

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 zero description coverage for the three parameters (start_date, end_date, group_by). The description does not explain date formats, allowed group_by values, or how the default 'category' is applied, leaving critical usage details undefined.

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 aggregates spending with flexible grouping ('by category | subcategory | merchant | account'), which is a specific and unambiguous purpose. The verb 'aggregate' and the listed dimensions precisely convey what the tool does.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like search_transactions_tool or get_transactions_tool. It only mentions that it reads a cache populated by sync_transactions, which hints at a prerequisite but does not clarify selection criteria.

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 behavioral disclosure. It does say the tool merges three data sources and ranks/projects, which is useful. But it does not explicitly confirm read-only behavior, error conditions, or what happens when no Plaid data is linked; a summary tool implies no mutation but leaves that implicit.

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

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

Two sentences with no filler; the main action is front-loaded and the data-scope sentence earns its place. This is appropriately concise.

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

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

For a tool with three meaningful parameters, no output schema, and no annotations, the description is too thin. It omits parameter semantics, expected output shape, and failure modes such as a missing Plaid connection. It works as a high-level summary but not as a complete call specification.

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

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

Schema description coverage is 0% and the description names none of the three parameters (today, strategy, extra_monthly_payment). The only indirect hint is 'project payoff timelines,' which does not explain the strategy default, how extra_monthly_payment changes results, or the role of today. This is a major gap.

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

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

The description opens with a clear verb+object ('Rank every debt') and explains it projects payoff timelines, which distinguishes it from raw retrieval siblings like get_liabilities_tool and list_external_debts_tool. It doesn't explicitly name those siblings, so it misses the top score, but the purpose is unambiguous.

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

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

It gives clear context: use this when a consolidated, ranked debt picture with payoff projections is needed, and the 'Plaid-only' note plus mention of overrides/external debts clarifies scope. It does not explicitly state when not to use it or name alternatives, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does disclose useful behavioral traits: idempotent, incremental, cursor-based, and cache-writing. However, it does not explain side effects on the local cache, return behavior, error handling, or the effect of wait_for_ready/wait_timeout_seconds.

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 compact sentences are front-loaded with purpose, then behavior, then usage routing. No filler or redundant restatement of the tool name.

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 sync tool with two optional parameters and no output schema, the description covers selection and invocation basics but omits return values, failure modes, and wait-parameter semantics. It is adequate, not complete.

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

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

The schema has 0% description coverage and the description never mentions wait_for_ready or wait_timeout_seconds. The names and defaults hint at waiting behavior, but an agent cannot understand what 'ready' means or how the timeout is applied.

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

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

The description opens with a specific verb and resource: 'Pull the latest transactions from Plaid into the local cache.' It clearly identifies the source (Plaid) and differentiates from the sibling get_transactions_tool by stating 'Plaid-only' and contrasting Teller behavior.

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

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

It gives explicit when-to-use guidance: use this for Plaid cursor-based sync, and explicitly names get_transactions_tool as the alternative for Teller live date-range fetches. The idempotent/incremental note also tells agents this tool is safe to reuse.

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 does disclose that only a subset of fields is updated and that the debt already exists, which is useful. But it does not explain what happens when a field is omitted versus set to null, whether changes are reversible, or what occurs if the debt_id does not match an existing debt.

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

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

The description is extremely concise and front-loaded. The first sentence states the action and scope, and the second adds a relevant constraint. There is no filler or redundant restating of the tool name.

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 eight parameters, no annotations, and no output schema, the description is too sparse. It does not explain required parameters, null-vs-omit semantics, return values, or error behavior, leaving significant gaps for an agent trying 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 description coverage is 0% and the description does not compensate. It does not mention debt_id as the required identifier or clarify that null values likely mean 'clear the field' rather than 'leave unchanged.' With eight parameters and no descriptions, an agent is left to infer the meaning and update semantics from names and types 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 identifies the operation as updating an existing external debt and emphasizes partial updates ('any subset of fields'), which distinguishes it from sibling tools like add_external_debt_tool, remove_external_debt_tool, and list_external_debts_tool. The resource and action are both specific and unambiguous.

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

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

The description implies usage: update an existing external debt, and the 'Plaid-only' note provides a useful eligibility constraint. However, it does not explicitly say when not to use it or mention alternatives such as add_external_debt_tool for creating debts or remove_external_debt_tool for deleting them.

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