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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior, and the description's 'Read-only' repeats that. However, it adds valuable domain context beyond the annotations: Nessie account data provides no credit limit, so credit utilization cannot be calculated from it. This helps an agent avoid misusing the data.

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: the first states the operation and input, the second adds an essential domain caveat. There is no filler, and the most important information is front-loaded.

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

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

For a single-parameter, read-only lookup with rich annotations and full schema coverage, the description is nearly complete. It even includes a meaningful limitation that is not visible from the schema. A brief note on the return shape would make it fully self-contained, but the low complexity makes that non-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 only parameter, accountId, is already fully described in the schema as an opaque string id with no assumed format or length. The tool description repeats 'opaque account id' without adding new semantic information, so the schema carries the burden and the baseline score of 3 applies.

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

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

The description uses a specific verb and resource: 'Get one Nessie account by opaque account id.' This clearly distinguishes it from nessie_list_accounts (one vs. list) and other siblings like nessie_get_customer or nessie_get_transactions.

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

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

The description makes the usage context obvious: use this tool when you have an opaque account id and need that single account. It does not explicitly name alternatives or excluding conditions, but the singular scope and id-based retrieval are clear enough for an agent to select it correctly.

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

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

The annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the 'Read-only' sentence is mostly redundant. The description does add a useful behavioral cue that exactly one customer is returned, but it does not describe not-found behavior, error cases, or the response shape. There is no contradiction with the annotations.

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

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

The description is appropriately short and front-loaded with the verb, resource, and lookup key. The only minor redundancy is 'Read-only,' which repeats an existing annotation, but it does not meaningfully bloat the description.

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 one-parameter read-only fetch with full schema coverage and safety annotations, the description is nearly complete for correct invocation. The main gap is that there is no output schema and the description does not explicitly state what happens for an unknown customer ID or the exact return shape; 'get one customer' covers most of the intent.

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

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

Schema coverage is 100%, and the schema already documents customerId as an opaque string with minLength 1. The description's phrase 'opaque customer id' merely restates that schema detail and confirms the parameter is the lookup key; it adds no new format, default, or edge-case 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 opens with a specific verb and resource: 'Get one Nessie customer by opaque customer id.' The singular 'one' and the ID-based lookup make it clear this is a single-resource fetch, and 'Read-only' distinguishes it from mutation tools. It is unambiguous against siblings like nessie_list_customers or nessie_get_account.

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

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

The description implies the right usage — fetch one customer when you already have an opaque customerId — but it never explicitly states when to prefer this over nessie_list_customers or when not to use it. This is implied usage rather than stated guidance, and no alternatives are named.

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

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

Annotations already mark it read-only, idempotent, and non-destructive; the description adds useful behaviors beyond those: newest-first ordering, literal transaction type tags, and the limitation that credit utilization cannot be derived from Nessie account data. No contradiction with annotations.

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

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

Three tight sentences lead with the core action and output, then declare read-only safety, then add a relevant limitation. No filler or repetition of schema details.

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

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

For a single-required-parameter read-only list operation, the description covers what is returned, ordering, safety, and an important analytic limitation. The absence of an output schema is mitigated by the explicit description of the feed and tags.

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

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

There is only one parameter, accountId, and its schema description already explains it thoroughly as an opaque string id. The tool description does not add parameter-specific semantics, so it relies on the 100% schema coverage.

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

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

The description names a specific verb ('List'), the resource ('an account's deposits and withdrawals'), and the distinguishing output ('one newest-first feed with literal transaction type tags'). This clearly separates it from sibling tools nessie_list_deposits and nessie_list_withdrawals, which return only a single transaction type.

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

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

It establishes the use case: retrieve an account's combined deposit and withdrawal activity in reverse chronological order. It does not explicitly name alternatives or exclusions, but the 'one ... feed' phrasing implicitly contrasts with the sibling list_deposits/list_withdrawals 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds the specific caveat that Nessie account data has no credit limit and credit utilization cannot be calculated, which is behavioral context beyond the annotations. It does not contradict any annotations.

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

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

The description is two concise sentences. The first sentence states the action and scope directly; the second adds a pertinent caveat. No wasted words, and the key information is front-loaded.

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

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

The tool is simple (one parameter, list operation) and the annotations already cover safety. The description includes the essential purpose and an important limitation. Since there is no output schema, it doesn't need to explain returns. 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% and the customerId parameter is well-documented in the schema (opaque string, do not assume format). The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'List' with the resource 'accounts' and scope 'owned by one Nessie customer,' which makes it distinct from sibling listing tools like list_deposits or list_withdrawals. It also adds a read-only qualifier and a caveat about credit limits, further specifying the tool's purpose.

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

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

The description implies use when you need all accounts of a specific customer, but it does not explicitly state when to prefer this over alternatives (e.g., get_account for a single account) or when not to use it. The credit-limit note hints at a limitation but does not provide clear selection guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds a meaningful limitation beyond that: Nessie account data provides no credit limit, so credit utilization cannot be calculated. No contradiction exists.

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

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

The main purpose is front-loaded in a single scoped sentence, and the credit-limit caveat provides useful context. The standalone 'Read-only' sentence is redundant with the annotations, creating minor waste but not enough to lower the score further.

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 one-parameter, read-only list tool with rich annotations and no output schema, the description provides sufficient information to call it correctly. It lacks output-shape and alternative-selection details, but those are not critical at this level of complexity.

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

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

The input schema already documents accountId at 100% coverage as a required opaque string with a format warning. The description only reinforces that the ID belongs to a Nessie account, adding no operational detail beyond the schema, so the baseline score of 3 is warranted.

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 object, 'List bills and recurring obligations,' and scopes the action to a single Nessie account. This differentiates it from sibling list tools by resource, though it never explicitly contrasts alternatives.

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

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

There is no guidance about when to use this tool versus list_deposits, list_withdrawals, list_loans, or other siblings. The credit-limit caveat is a data limitation, not a usage directive, so the agent is left 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?

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds the explicit 'Read-only' phrase and the authorization scope ('available to the configured API key'), which slightly enriches the behavioral context but does not disclose additional traits like pagination or return format. No contradiction with annotations.

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

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

Two short, front-loaded sentences with no filler. The core scope ('List all Nessie customers') leads, and the safety note follows. Every word earns its place.

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

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

For a zero-parameter, read-only list operation with no output schema, the description is essentially complete. It clearly states what is listed and under whose scope. A minor gap is the lack of explicit return shape, but the verb 'List' implies a collection.

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 there is nothing for the description to clarify. The schema is an empty object, and 100% coverage is vacuously true. Baseline for no parameters is 4.

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

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

The description uses a specific verb ('List'), a clear resource ('all Nessie customers'), and a scope qualifier ('available to the configured API key'). This clearly distinguishes it from sibling tools like nessie_get_customer (single customer) and nessie_list_accounts (accounts, not customers).

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

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

The description gives clear context: use this to list all customers accessible via the configured API key. However, it does not explicitly name alternatives or state when not to use it, leaving some sibling differentiation to inference.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds a valuable domain caveat that Nessie account data lacks credit-limit information, preventing misuse for credit-utilization calculations. No contradiction with annotations.

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

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

Two concise sentences with the core action front-loaded and a useful caveat after it. There is no filler or redundant explanation; every clause earns its place.

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

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

For a simple one-parameter read-only list tool with annotations covering safety and the schema covering the parameter, the description is complete. The scope is clear, the return is implied by 'List deposits,' and the added domain caveat covers a likely misuse.

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

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

The schema fully documents accountId at 100% coverage, including its opaque-string nature and the warning not to assume format or length. The description does not need to add parameter details; the baseline 3 is appropriate.

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

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

The description uses a specific verb ('List'), a clear resource ('deposits'), and a specific scope ('one Nessie account'). This cleanly distinguishes it from sibling tools like nessie_list_withdrawals, nessie_list_bills, and nessie_list_loans, so an agent knows exactly what it 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 makes the read-only context explicit and provides a clear when-not-to-use signal: credit utilization cannot be calculated from Nessie account data. It does not explicitly name sibling alternatives, but the resource-specific wording makes the intended use obvious.

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

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

Beyond the annotations' read-only hint, the description adds important behavioral context: the credit_score is a static on-file value, not a live credit-bureau feed, and Nessie account data cannot support credit utilization calculations. This prevents an agent from misinterpreting loan fields as real-time financial data.

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 lead with the core purpose, then add only high-value caveats. No filler or redundant schema restatement; every sentence earns its place.

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

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

For a single-parameter, read-only list tool, the description fully covers what the tool does, the required account context, and the meaning of its loan fields. No output schema exists, but the description adequately supports correct invocation without needing to detail return values.

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

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

Schema coverage is 100%, and the accountId parameter is already documented as an opaque string with no format assumptions. The description reinforces that the parameter identifies 'one Nessie account', but it does not add significant new semantic detail 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?

States a specific verb ('List') and resource ('loans') scoped to 'one Nessie account', clearly distinguishing it from sibling tools that list deposits, withdrawals, bills, or accounts. The loan-focused resource is unambiguous and an agent can choose this tool without opening the schema.

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 makes the usage context clear: it lists loans for a single, specified Nessie account. It does not explicitly name alternatives or exclusion conditions, but the tool's scope is sufficiently clear given the sibling set contains no other loan-listing tool.

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

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

Annotations already cover readOnly/idempotent/non-destructive safety. The description adds a non-obvious data limitation—no credit limit exists in Nessie account data, so credit utilization cannot be calculated—which is useful context beyond structured fields. It does not contradict the annotations.

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

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

The core action is front-loaded and the total length is short. However, the standalone 'Read-only.' sentence simply repeats the readOnlyHint annotation and could be removed without loss, preventing a perfect score.

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 one-parameter, read-only list tool, the description, schema, and annotations are sufficient for an agent to select and invoke it correctly. Return format and pagination are not mentioned, but the low complexity and fully documented accountId make this 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 single required accountId is fully documented in the schema, including that it is an opaque string. The description adds no parameter-specific details beyond saying 'one account,' so it meets the schema-coverage baseline of 3.

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

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

The description uses a specific verb ('List'), names the resource ('withdrawals'), and constrains scope to 'one Nessie account.' This clearly distinguishes it from sibling tools like list_deposits, list_bills, and get_transactions.

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

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

It gives clear context: withdrawals are scoped to a single account, the operation is read-only, and the data cannot be used to calculate credit utilization. It does not explicitly name an alternative tool for broader transaction queries, 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.