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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description earns credit for the non-obvious behavioral detail that the overdraft is included in the evaluation, which the annotations cannot convey. It stops short of saying whether it throws, returns a flag, or what happens on an unknown account.

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?

A single front-loaded sentence with no filler: the action, the subject, the required input, and the overdraft nuance all appear in the first clause set. Nothing could be removed without losing 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?

There is no output schema, so the description carries the burden of describing the return value and it does not—an agent cannot tell whether it gets a boolean, an available-balance figure, or a structured result. For a read-only confirmation check the missing return/error contract is the main 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 100%: both parameters are fully documented, including the accountUid default resolution chain and the minor-units convention (1050 = £10.50). The description adds only 'the given amount', so the schema does the heavy lifting and baseline 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?

States a specific verb ('checks') and resource ('account funds') plus the exact condition being evaluated (enough available money for a payment), and adds that the overdraft is factored in. This makes it distinguishable from get_account_balance, though the description never names that sibling to make the boundary 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?

Usage is implied rather than stated: 'for a payment of the given amount' hints it is a pre-payment affordability check. There is no explicit when-to-use, when-not-to-use, or named alternative (e.g. get_account_balance) an agent could route against.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: the file is written to the download directory with owner-only permissions, the return value is a path, and images are additionally displayed inline.

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 dense, front-loaded sentences with no filler; the core action comes first and the side effects and return behavior follow immediately.

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

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

With no output schema, the description correctly carries the return-value burden by stating a path is returned and images are shown inline, and it discloses the on-disk write. What is missing is only the explicit sequencing relationship with list_transaction_attachments, which the schema hints at but the description does not state.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including the account/category defaults and the saveAs path semantics. The description adds no parameter-level detail beyond this, so the baseline 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 states a specific verb and resource ('Downloads a file attached to a transaction') and adds scope details — saves to the download directory, returns the path, renders images inline. It is clearly distinct from list_transaction_attachments, though it never names that sibling explicitly to make the differentiation airtight.

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?

Usage is only implied: the attachment UID parameter notes it comes from list_transaction_attachments, which sketches the workflow. The description itself gives no explicit when-to-use, prerequisites, or when-not-to-use guidance (e.g., use list_transaction_attachments first to discover UIDs).

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, non-destructive and open-world, so the bar is lower. The description still adds real behavioral detail the annotations do not: the CSV is written to disk with owner-only permissions, the path is returned, and inline=true additionally returns the CSV text. It omits what happens on file-name collisions or error conditions, but the side-effect profile is well 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?

Two sentences, zero filler, and the core artifact and scope are front-loaded before the optional inline behavior. 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?

With no output schema, the description correctly carries the return contract (saved file path, plus CSV text when inline=true) and the destination directory behavior. It stops short of edge cases such as overwriting an existing file, which is a minor gap rather than a blocking one.

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

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

Schema description coverage is 100%, so all five parameters including saveAs, accountUid and inline are already documented, giving a baseline of 3. The description restates inline and frames accountUid implicitly as 'the main account', which only loosely matches the schema's env-var/only-account/PRIMARY resolution order, adding little beyond the schema text.

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 (downloads), a specific artifact (Starling's CSV export), the data scope (all settled transactions on the main account) and a range constraint, plus 'the same export as the app' to anchor what the file contains. An agent can separate this from the JSON transaction-reading siblings purely from the text.

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?

Usage is implied: reach for this when a file-formatted statement export is wanted rather than JSON records, and the inline=true cue is a use-time condition. However, with ~50 siblings including list_settled_transactions and list_transactions, the description never names the alternative or states a when-not, leaving the agent to infer the routing.

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 this a safe, idempotent, non-destructive read, so the description's job is to add operational context, and it does: it discloses what is scanned (outgoing transactions only), the default lookback, the sort order (annual cost), and the derived fields returned, including an activity heuristic. It falls short of explaining how 'still looks active' is determined or any heuristic 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?

A single, front-loaded sentence with the scope and default stated before the return-value list; nothing is padded. The trailing list of returned fields is dense but each item is informative, so no sentence is 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?

With no output schema, the description correctly carries the burden of describing returns (cadence, amounts, next expected date, annual cost, sort order) and scope defaults. Combined with complete annotation coverage and a fully documented parameter schema, an agent has what it needs; only the definition of the activity heuristic is left unclear.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters including defaults and the minOccurrences bounds. The description only restates the value of the active filter and the 12-month default window, adding no new parameter semantics; baseline 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 names a specific verb and resource ('scans outgoing transactions ... for payments that repeat on a regular cadence') and enumerates what qualifies: subscriptions, direct debits, standing orders, memberships. It further distinguishes itself from the list_* siblings by stating it returns derived values (cadence, next expected date, estimated annual cost), making it obviously an analytical detection tool rather than a mandate/order listing call.

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?

Usage is implied by the capability description (use this to discover recurring outgoings), and the description states the default window of the last 12 months plus the activeOnly toggle. But it never says when to prefer this over list_standing_orders or list_direct_debit_payments, nor any exclusions or prerequisites, so the guidance stays implicit.

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 read-only, idempotent, non-destructive behavior, so the safety profile is covered. The description adds real behavioral value beyond that: it defines clearedBalance vs effectiveBalance, notes total* fields include spaces/savings goals, states amounts are minor units, and mentions a formatted summary is returned.

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?

Every clause carries distinct information (field definitions, scope of totals, units, output format) and the core purpose is front-loaded. Dense but no wasted sentences.

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

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

With no output schema, the description steps in to explain the meaning of the key returned balance fields and their units, which is exactly what an agent needs to interpret results. The only gap is the absence of usage routing versus check_funds.

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

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

Schema coverage is 100%, so the schema already documents the single accountUid parameter including its default-resolution behavior. The description adds nothing about the parameter itself, which is the correct baseline when the schema does the work.

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

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

States a specific verb and resource ('Gets an account's balance') and clarifies the field semantics. It does not, however, differentiate itself from the sibling check_funds, which an agent could plausibly confuse for the same capability.

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 when-to-use guidance, no exclusions, no mention of alternatives such as check_funds. Usage is only implied by the tool name and by the field explanations.

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, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds value beyond that by fixing the enumerable output domain and framing the tool as a router, though it does not say what happens when no holder exists or whether the call is cheap/cacheable.

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, zero filler, and the routing insight is placed after the return contract where it is most useful. Nothing could be removed without losing 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?

With no output schema, the description carries the burden of explaining the return value and does so precisely (UID plus one of four type values), then tells the agent what to do with that result. Complete for a zero-parameter lookup of this scope.

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 takes zero parameters, so there is nothing for the description to disambiguate; per the rubric a 0-parameter tool has a baseline of 4. The description correctly stays silent on inputs rather than inventing any.

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 and resource ('Returns the account holder UID and type') and enumerates the exact return domain (INDIVIDUAL, JOINT, SOLE_TRADER, BUSINESS). This clearly separates it from close siblings like get_account_holder_name, which returns a name rather than an identity/type pair.

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 second sentence gives real routing guidance: the returned type determines which downstream details tool applies, implicitly pointing at get_individual_details / get_joint_account_details / get_business_details / get_sole_trader_details. It stops short of naming the specific tool per type value, so it is clear context rather than a fully explicit when-to-use rule.

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 fully cover the behavioral profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint), which lowers the bar, but the description adds nothing beyond that: no note on fallback behavior when no holder name exists, no indication of null/empty results, and no hint about which account/resource it applies to.

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?

A single short sentence with no filler and the essential information front-loaded. It is not over-verbose, though its brevity borders on under-specification rather than disciplined conciseness.

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

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

For a zero-argument getter whose annotations carry the safety profile and which has no output schema, the description is barely adequate. It does not clarify the return shape (a plain name string vs. a holder object) nor its relationship to get_account_holder, which is the main ambiguity an agent would face.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. Schema coverage is 100% and there are no arguments to misread.

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 verb and a resource ('Returns the account holder's name'), but it is essentially a verbatim restatement of the tool name/title. It gives no differentiation from close siblings such as get_account_holder, get_individual_details, or get_joint_account_details, leaving the agent unable to tell why this narrower tool exists.

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 when-to-use guidance, no statement of prerequisites, and no mention of the sibling get_account_holder that presumably returns the same information plus more. The agent must infer selection entirely from the tool name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safe-read profile is fully covered. The description adds the concrete return payload (sort code, account number, IBAN, BIC, other identifiers), which is useful beyond the annotations but not deep behavioral context.

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

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

A single front-loaded sentence with no filler; the parenthetical '(and any other identifiers)' usefully signals variability in the payload. Efficient, though it could be trimmed slightly.

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 is no output schema, so the description's field enumeration carries the return-value burden, and it does so adequately. For a simple read-only lookup with full annotation coverage and a fully-documented parameter, this is close to 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?

Only one optional parameter, and schema description coverage is 100% — the schema already explains the accountUid fallback chain (STARLING_DEFAULT_ACCOUNT_UID, single account, PRIMARY). The description adds nothing about it, which is acceptable when the schema does the work.

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

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

States a specific verb (gets) and resource (account identifiers), and enumerates the returned fields — sort code, account number, IBAN, BIC. This distinguishes it from siblings like get_account_balance or get_account_holder, though it does not name them explicitly.

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

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

No guidance on when to use this tool versus the many other account-related getters in the sibling list (get_account_balance, get_account_holder, get_sole_trader_details). The schema's default-account note is the only routing hint, and it lives in the schema, not the description.

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, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds one genuinely useful behavioral fact beyond those annotations: it returns historical (previous) addresses, not just the current one.

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?

A single tight sentence with the resource and scope front-loaded and zero filler. Nothing redundant with the title or annotations.

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 with full annotation coverage, the description is close to sufficient; the mention of current and previous addresses signals a multi-item return. With no output schema, a hint about the return shape (e.g., how addresses are labelled) would make it 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 tool takes zero parameters, so there is no parameter semantics for the description to carry; baseline is 4. Nothing in the description misleads about inputs.

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 (Returns) and resource (the account holder's current and previous addresses), so the agent knows exactly what it fetches. It does not, however, distinguish itself from siblings like get_business_registered_address or get_business_correspondence_address, which also return addresses.

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 when-to-use guidance, prerequisites, or named alternatives. The agent must infer from the sibling list whether this is the personal-address tool versus the business-address siblings, which is exactly the distinction that matters here.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the returned data fields, which is useful, but says nothing about behaviour when no authorising individual is present or what authorisation context is assumed.

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?

A single, front-loaded sentence with the resource stated first and the return payload in parentheses. 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?

With no output schema, the parenthetical field list partially compensates by telling the agent what comes back. However, it omits edge-case behaviour (no authorising individual, token types without one), which matters for a zero-parameter lookup tool an agent must call blind.

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 takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate beyond the implicit 'this token' scope, which it does state.

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 (Returns) and resource (the person who authorised this token), plus the fields returned. It is clearly distinguishable from siblings like get_token_identity or get_individual_details, though it does not explicitly name those alternatives.

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

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

No guidance on when to use this versus other identity-returning siblings, and no preconditions (e.g. which token, whether an authorising individual always exists). The agent must infer usage entirely from the name and phrasing.

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, idempotentHint and destructiveHint=false, so safety is covered. The description adds the genuinely useful behavioral detail that the value falls back to the registered address when no correspondence address exists — a non-obvious runtime trait that the annotations do not convey.

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?

A single front-loaded sentence that identifies the audience, the value returned, and the fallback rule 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 parameterless, read-only lookup with no output schema, the description covers what is returned and the fallback case. It could go slightly further on what happens when neither address exists, but nothing essential to invoking it is missing.

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?

Zero parameters, so per the rubric the baseline is 4. The schema has nothing to document and the description correctly spends no space on parameter 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 names the resource (correspondence address) and scopes it to business account holders, which separates it from get_addresses and get_business_registered_address via the fallback clause. It never states an explicit verb like 'retrieve', relying on the tool name to carry that, so it falls just short of full sibling-level clarity.

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?

'Business account holders:' functions as an implicit precondition, telling the agent the calling context. However it never says when to prefer this over get_business_registered_address or get_addresses, nor any exclusions, so usage is only implied.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety and repeatability profile is covered. The description adds no auth requirements, rate limits, or failure behavior, but it does enumerate the returned content, which is meaningful given there is no output schema.

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?

A single short fragment with no padding, front-loading the resource type. It loses a point only because the terminal 'etc.' signals an incomplete field list rather than a deliberate summary.

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 parameterless read-only call with no output schema, the description is the only signal about what comes back, and it lists a few fields followed by 'etc.' That is minimally adequate but leaves the return shape genuinely uncertain, so an agent cannot rely on it to know exactly what it will receive.

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 takes zero parameters, so there is nothing for the description to disambiguate. Per the baseline for parameterless tools, a 4 is appropriate — the schema is empty and needs no compensation.

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 the resource ('Business account holders') and enumerates some fields, which distinguishes it loosely from get_individual_details and get_sole_trader_details. However, there is no verb at all — it never says it retrieves or returns anything — and the trailing 'etc.' leaves the scope undefined, so it reads closer to a restatement of the title than a stated 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?

No when-to-use guidance is given. With siblings like get_individual_details, get_sole_trader_details, and get_account_holder, an agent needs to know this is the one for business-type holders, but the description only hints at that via the noun phrase 'Business account holders' and names no alternatives or conditions.

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 readOnly, idempotent, non-destructive and open-world, so the safety profile is fully covered externally. The description adds only a mild precondition ('business account holders'), which hints the call may not apply to personal accounts, but says nothing about failure modes or what is returned. With annotations carrying the load, this is minimal added context.

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

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

A single short fragment with no padding, and the scope qualifier leads the sentence. It is efficient, though the colon-fragment construction reads more like a label than a 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?

With no parameters and no output schema, the description is the only place the return shape could be hinted, and it is not — the agent does not know the address fields or what happens for a non-business account. For a trivial single-value getter this 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 tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline of 4 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 identifies the resource (the company's registered address) and a scope qualifier (business account holders), but it is a noun phrase that largely restates the name/title rather than stating a verb+resource action. It does implicitly distinguish itself from the sibling get_business_correspondence_address by naming 'registered', which is a real, if small, differentiating cue.

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 on when to call this versus the obvious alternative, get_business_correspondence_address, nor any stated prerequisite beyond the implicit 'must be a business account holder'. The agent must infer the appropriate context entirely.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered by structured data. The description adds behavioral context by restricting applicability to card payments (Mastercard), signalling it is not useful for non-card transactions, but omits what happens if the feed item is not a card payment.

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?

A single, front-loaded sentence with the most relevant scoping qualifier ('For card payments') first and no redundant padding. It is a fragment without an explicit verb, but it wastes no words.

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

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

With no output schema, the description usefully enumerates the kind of values returned (merchant identifier, MCC, POS time, authorisation code, last 4 digits), which partially compensates. It still omits error/empty cases and how the feedItemUid is obtained, leaving gaps for a lookup tool.

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

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

Schema description coverage is 100%, so baseline is 3: accountUid, categoryUid and feedItemUid are all documented in the schema itself, including defaulting behavior. The description adds no parameter meaning beyond the schema.

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

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

The description identifies a specific resource and scope: card-payment (Mastercard) transaction details, which implicitly separates it from the generic 'get_transaction' sibling. However, it is written as a noun phrase listing fields rather than a verb+resource statement, so the action ('retrieve details for a card transaction') must be inferred from the tool name.

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 on when to use this tool versus siblings such as get_transaction or list_transactions, and no prerequisites or conditions are stated. The only hint is 'For card payments', which is a scope qualifier rather than usage 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=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that – no auth requirements, no not-found/error behavior, no indication of what is returned, despite openWorldHint implying external data may not exist.

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

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

A single short sentence, front-loaded with the verb and resource and free of padding. It is efficient, though the extreme brevity leaves no room for the routing guidance an agent would benefit from.

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 read tool with full schema coverage and annotations covering safety, the description is minimally adequate. It omits return-shape expectations and error handling, which for an openWorldHint tool that may fail to find a mandate would be useful.

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 a single parameter and 100% schema description coverage, the schema already documents mandateUid. The description does not add format, sourcing, or validation meaning beyond the schema, so the baseline 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 states a verb (Gets) and resource (direct debit mandate) plus cardinality (one), which is more than a bare restatement of the title. However, it is nearly a tautology against the title 'Get direct debit' and gives no hint of how it differs from the sibling list_direct_debit_mandates beyond the word 'one'.

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 when-to-use guidance, no mention of alternatives such as list_direct_debit_mandates, and no statement of prerequisites (e.g. that a valid mandateUid must already be known). The agent must infer everything from the sibling name.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so safety is covered. The description adds a genuinely new constraint not present in the schema or annotations — 'within the last year' — plus the kinds of changes that surface (status changes, settlements, notes, category edits), both of which affect how an agent picks a lookback window.

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 tight sentences with the core behavior front-loaded and the sync use case, including the one-year limit, placed immediately after. The example enumeration is slightly list-y but each item conveys what triggers a feed item.

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

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

With no output schema, the description carries the return-value burden; it tells the agent what items appear but not the shape, ordering, or pagination behavior of the feed — notable gaps for a sync tool. The one-year constraint is a helpful addition, but return mechanics remain unspecified.

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

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

Schema description coverage is 100%, so all four parameters are already documented, establishing a baseline of 3. The description only marginally extends changesSince by implying the one-year lookback; it adds nothing about the enum values in `detail` or the account/category defaults.

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 and resource ('Returns feed items created or updated since a timestamp') and scopes it, which separates it from the plain list_transactions/get_transaction siblings by its delta/sync nature. It never names a sibling, so an agent gets the concept but not an explicit disambiguation.

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?

'Useful for syncing' implies the intended context but gives no explicit when-to-use rule, no exclusion of nearby alternatives (list_transactions, list_settled_transactions), and no guidance on choosing it over a plain transaction list.

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

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

Annotations already cover read-only, idempotent, non-destructive and open-world semantics, so the burden is low. The description still adds real value by disclosing the cost profile ('Uses 1 + 2 requests per account') and enumerating which balance types and spaces are returned, which matters because there is no output schema.

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

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

Two sentences, front-loaded with the outcome and followed by the cost note, with no redundant restatement of the title or annotations.

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

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

With no output schema, the description carries the return-value burden and does enumerate the shape of the snapshot (cleared/effective/total balances, savings and spending spaces). It omits any error or partial-failure behavior, which slightly limits completeness for an aggregate call.

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 takes zero parameters, so per the rubric the baseline is 4; there is nothing for the description to clarify beyond the implicit 'all accounts' scope.

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 resource and an aggregation verb: 'one-call snapshot of every account' with balances and spaces. It is clearly distinguishable in behavior from list_accounts and get_account_balance because it aggregates them, though it never names those siblings explicitly.

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

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

'One-call snapshot' implies the usage case (fetch everything at once rather than making many calls), but there is no explicit when-to-use vs. when-to-use-an-alternative statement, nor any exclusions such as 'prefer list_accounts for pagination'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by disclosing the shape of the returned data (the specific personal fields), but says nothing about whose record is returned, auth requirements, or scope 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?

A single compact fragment with no filler, and the scoping term ('Personal account holders') is front-loaded. It is efficient, though the fragmentary style loses a little clarity compared with a full 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?

With no parameters and no output schema, the description carries the burden of explaining what comes back, and the field list does that reasonably well. What it omits is the key ambiguity for a zero-argument getter: which individual's details are returned (the authenticated holder?), leaving the agent without full context.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. The description's field list is essentially return-value documentation rather than parameter 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 names the resource (personal account holders) and enumerates the fields returned (title, name, date of birth, email, phone), which lets an agent infer it retrieves an individual's details. However, it is a noun-phrase fragment with no explicit verb, and it never distinguishes itself from similarly-named siblings like get_account_holder or get_joint_account_details, which also concern personal account holders.

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 when-to-use guidance, no mention of prerequisites, and no reference to any alternative tool. The agent is left to infer the use case from the name alone, despite many overlapping sibling getters (get_account_holder, get_joint_account_details, get_sole_trader_details).

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, idempotentHint and openWorldHint, so the safety profile is covered. The description contributes nothing beyond restating the title and the 'two people' scope; it does not say whether it errors on non-joint accounts, what identity/consent is required, or what data is returned.

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?

A single short sentence with no filler and the distinguishing scope ('joint', 'both people') front-loaded. It is efficient, though it is arguably under-specified rather than 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 no-parameter, read-only lookup the description is minimally viable, but with no output schema it should say what the returned details cover (names, identifiers, roles) or how it behaves for sole accounts. That gap keeps it at the minimum-viable level.

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?

Zero parameters, so the baseline is 4 per the rubric. Schema coverage is 100% and there is nothing for the description to clarify.

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 fragment 'Joint account holders: details of both people on the account' identifies the resource and a distinguishing scope (joint, two holders), which separates it from get_account_holder and get_individual_details. However, it is a noun phrase rather than a verb+resource statement, so the action (retrieve) and the exact entity returned (the joint account record vs. the two holders) remain slightly ambiguous.

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

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

No guidance on when to use this versus the many sibling lookups (get_account_holder, get_individual_details, get_business_details). The agent must infer that this applies only to jointly-held accounts from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety and repeat-call profile is fully covered without the description. The description adds only the return scope ('and its accounts'), which is genuinely useful since there is no output schema. It says nothing about behavior on an unknown UID, so it adds modest value.

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

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

One short sentence, front-loaded with the verb and resource, with zero filler. Nothing could be trimmed without losing 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 single-parameter read tool with rich annotations, the description covers purpose and roughly what comes back (payee plus its accounts). It omits failure behavior (invalid or unknown payeeUid) and any note on how this relates to the many sibling payee tools, so it is adequate but has clear gaps.

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

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

Schema description coverage is 100% and the single payeeUid parameter is documented with its UUID pattern in the schema itself. The description adds no format, source, or lookup hints beyond 'one saved payee'. Baseline 3 is correct when the schema carries the parameter burden entirely.

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+resource ('Gets one saved payee') and scopes it to a single record, which implicitly separates it from the sibling list_payees. It also notes the payload includes the payee's accounts. It stops short of explicitly naming the sibling it is not, so sibling differentiation is inferred rather than stated.

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 when-to-use guidance: nothing says to call this after list_payees, or how it differs from list_payee_payments, get_payee_image, or other payee-adjacent siblings. The singular 'one saved payee' hints at lookup semantics but no condition or alternative is 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 declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description usefully adds the return format (PNG) and the conditional-existence caveat, but omits the side effect implied by the saveAs parameter (writing a file) and what is returned or raised when no image 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?

A single front-loaded sentence with zero filler; the return type and the existence condition are packed in without padding.

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

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

For a simple read-only tool with no output schema, stating the format and the possible-absence condition covers the essentials. It falls short only on the saveAs side effect and the precise no-image behavior, which an agent invoking it would benefit from knowing.

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 both parameters (payeeUid, saveAs) are documented in the schema, so the baseline of 3 applies. The description adds no syntax, format or constraint 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 (returns) and resource (the payee's image) plus the media format (PNG). It is distinguishable from siblings like get_profile_image or get_savings_goal_photo by the 'payee's image' qualifier, though it never names an alternative explicitly.

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

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

Usage is only implied: you call it when you need a payee's picture. There is no explicit when-to-use, no guidance on fallback when no image exists beyond 'if one exists', and no routing to or away from sibling image 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=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds only definitional context about what a payment order is, not beyond-schema behavioral detail such as error behavior for unknown UIDs or data freshness.

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?

One compact sentence with the resource and lookup key front-loaded and no filler. It is appropriately sized for a single-parameter lookup, though the parenthetical is the only content beyond the 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 simple by-UID lookup with full annotation coverage, 100% schema coverage and no output schema, the description is minimally adequate. It omits any routing hint relative to get_standing_order, which is the main gap an agent would face.

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 there is a single required parameter whose UUID pattern is enforced in the schema. The description only restates the identifier, adding no format or sourcing detail beyond the schema, so baseline 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?

States a specific verb (Gets) and resource (payment order), and usefully clarifies that a payment order may be an instructed payment or a standing order. However, it does not differentiate itself from the sibling get_standing_order or list_payment_order_payments, so an agent must infer the boundary.

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 when-to-use guidance and no mention of alternatives (get_standing_order, list_payment_order_payments are nearby siblings). Usage is only implied by the name and the required UID parameter.

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/idempotentHint/non-destructive, so safety is covered. The description adds two useful behavioral facts: the result may not exist, and it can write to disk. It does not describe the return format (binary, URL, base64) or file-overwrite behavior.

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, and the core purpose is front-loaded ahead of the optional side effect.

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 0-required-param read tool with full schema coverage and no output schema, the description is nearly sufficient. It states the return subject and the one notable side effect, though it could clarify what the returned image representation looks like.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the auto-lookup of accountHolderUid. The description's mention of saving to a file only restates the saveAs parameter, adding no syntax or path 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?

States a specific verb and resource ('Returns the account holder's profile image') and the conditional ('if one exists'). The 'account holder's' scope distinguishes it from sibling image tools like get_payee_image and get_space_photo, though it doesn't name 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 optional saving behavior is implied by 'Optionally also saves it to a file,' and the 'if one exists' clause hints at a possible empty result. However there is no explicit when-to-use guidance or routing against the other image-retrieval siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds no behavioral context beyond that (no auth/permission notes, no defaults, no rate limits), but nothing is left unmet either, so a minimum-viable 3 is appropriate.

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?

A single front-loaded sentence with zero waste; the most important fact (whether round-ups are active) comes first.

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

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

With no output schema, the description carries the return-value burden and does so adequately by naming the three returned facts (active state, destination savings space, multiplier). It is slightly incomplete in not clarifying the shape of the response or what happens when round-ups are disabled.

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% for the single accountUid parameter, including its pattern and default fallback, so the schema does the heavy lifting. The description adds nothing about the parameter, making the baseline 3 correct.

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 and resource ('Shows whether round-ups are active, which savings space they go to, and the multiplier'), enumerating exactly the three facts returned. It is clearly distinguishable from siblings like get_savings_goal or list_spaces by resource, though it never names an alternative to contrast against.

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?

Usage is only implied: an agent infers it should call this when it needs round-up status, destination space, or multiplier. There is no explicit when-to-use statement, no prerequisites, and no named alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds no behavioral context beyond what those annotations provide, such as error behavior, return shape, or account fallback details.

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

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

The description is a single short sentence with no wasted words and is front-loaded. It is appropriately compact, though it borders on under-specification for a tool definition.

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

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

For a simple read tool with full schema coverage and rich annotations, the description is minimally adequate. It does not describe return values or error cases, but with no output schema and strong annotations, those gaps are less critical.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds no additional parameter meaning, making the baseline 3 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?

States a specific verb ('Gets') and resource ('savings goal'), and the word 'one' distinguishes it from list_savings_goals. However, it does not name the sibling alternative explicitly, so it falls short of full sibling differentiation.

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

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

The description provides no when-to-use guidance, no prerequisites, and no alternatives. An agent must infer from the name and schema that a savingsGoalUid is required and that this is the single-item counterpart to list_savings_goals.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond that – in particular it never says what form the 'photo' takes (binary payload, URL, content type) or how absence of a photo is signalled.

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?

A single well-formed sentence with no filler, and the essential information (what is returned) is front-loaded. Nothing to trim.

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 two-parameter read tool with no output schema, this is barely adequate: the agent knows what it fetches but not the return representation or the empty/no-photo case. Annotations carry the safety profile, so the remaining gap is moderate rather than severe.

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

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

Schema description coverage is 100%, so both accountUid (including its default-resolution behavior) and savingsGoalUid are already fully documented in the schema. The description adds no parameter meaning beyond what the schema provides, which is the expected baseline.

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 and resource (returns the photo of a savings goal), which is clearly distinct from get_savings_goal and list_savings_goals. It does not, however, explicitly differentiate itself from the parallel image-fetching siblings like get_space_photo, get_payee_image, and get_profile_image.

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 statement of when to use this tool versus alternatives such as get_savings_goal (goal data) or get_space_photo, nor any precondition or error condition (e.g. what happens when no photo has been uploaded). Usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description's added value is the 'if one is set' conditional, warning that absence is a normal outcome. It does not disclose the shape of the returned transfer or any error/empty-result behavior.

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?

A single sentence with no filler, front-loading the action and resource, and the qualifying condition is placed at the end where it does not obscure the main claim. Nothing to trim.

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?

Inputs are fully covered by the schema and safety by the annotations, so the description only needs to carry the resource identity, which it does. With no output schema, though, it could reasonably say what the recurring transfer comprises (amount, frequency, next date), leaving a gap for an agent interpreting the result.

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% – both accountUid (with its default-resolution rules) and savingsGoalUid are fully documented in the schema. The description nods at the target ('into a savings space') but adds no format, defaulting, or identifying semantics beyond what the schema already states. Baseline 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?

States a specific verb (Gets) and a well-defined resource (the recurring transfer / automatic top-up into a savings space). The parenthetical gloss clarifies the domain term, distinguishing it from generic transaction or standing-order lookups. It stops short of naming a sibling it differs from, but the resource 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?

The clause 'if one is set' implicitly tells the agent this is a single-item lookup that may return nothing, which is a usable usage hint. However, it never states when to call this versus alternatives like get_round_up or get_standing_order, nor what a caller should do when no transfer exists.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral facts beyond that: it performs no API calls (so it cannot consume the quota it reports) and it surfaces a concrete limit of 1,000 requests/day for personal tokens. It stops short of stating auth requirements or how the confirmation setting affects other tools.

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?

A single sentence that front-loads the core purpose and then lists the returned fields, with the important 'Makes no API calls' constraint placed last for emphasis. It is dense but not padded; the parenthetical quota figure is the only mildly extraneous clause, though it is arguably load-bearing context.

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

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

With no output schema, the description carries the burden of describing what comes back, and it does so by enumerating the exact categories reported (environment, tier, signing, confirmations, request count). For a zero-parameter diagnostic tool with full annotation coverage, nothing an agent needs in order to call it correctly is missing.

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 zero parameters and 100% coverage, so there is nothing for the description to disambiguate. Per the zero-parameter baseline, a 4 is appropriate; no parameter-level detail is expected or useful 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 names a specific verb and resource (shows this server's configuration) and enumerates exactly what is exposed: environment, access tier, request signing, confirmation behavior, and daily request count. It is unmistakably distinct from every banking sibling (get_account_balance, list_transactions, etc.), which are all data-retrieval tools against the Starling API.

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?

Usage is only implied: the closing line 'Makes no API calls' hints that this is a free diagnostic safe to call before spending quota, but the description never says when to reach for it (troubleshooting, checking remaining quota, verifying tier) or when it is unnecessary. There is no true alternative tool to route against, so the omission is minor but real.

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 readOnly, idempotent, non-destructive, and open-world behavior, so the bar is low. The description adds useful context that the result may be absent ('if they have one'), but says nothing about auth, error shapes, 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?

A single front-loaded sentence that defines the resource and its payload with no wasted words. It is appropriately sized for a no-argument read operation.

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

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

With no output schema, the description does explain what the return represents (payment link/handle) and that it may not exist. It omits explicit null/empty-return behavior and response structure, which is a minor gap for a read tool whose annotations already cover safety.

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 are zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the structured fields, though no extra semantic detail 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?

States a specific verb (Returns) and resource (account holder's Settle Up profile), and even disambiguates the payload as a Starling payment link/handle. It does not differentiate itself from any sibling tool, so it stops short of a 5.

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

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

The only usage hint is the conditional 'if they have one,' which describes the result rather than when to call the tool. No alternatives are named and no when-to-use context is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered without the description. The description adds a partial view of the payload (three named fields), which is mild behavioral value but says nothing about auth requirements, whether the caller must be the account holder, or what happens for non-sole-trader accounts.

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?

A single short fragment with no filler; the key qualifier 'sole trader' is front-loaded. It loses a point for being an incomplete sentence that never states the action being performed.

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 is no output schema, so the description carries the burden of describing the return value; it names only three fields, leaving unclear whether name, address or identifier data are also included. For a no-parameter read tool this is close to adequate but noticeably thin.

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 takes zero parameters, so per the rubric the baseline is 4. The description correctly implies the tool is implicitly scoped to the authenticated account holder rather than taking an identifier.

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?

It identifies the specific resource (sole trader account holders) and enumerates the data returned (trading name, business category and subcategory), which distinguishes it from the sibling get_business_details, get_individual_details and get_joint_account_details. However, it is a noun fragment with no verb, so the retrieval action is only implied rather than stated.

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 when-to-use guidance, no prerequisites, and no mention of the closely related siblings (get_account_holder, get_business_details, get_individual_details) that an agent must choose between. The only cue is the phrase 'sole trader account holders', which the agent must interpret on its own.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds no behavioral context beyond that — it does not say what form the photo is returned in (binary, base64, URL) or what happens when a space has no photo, which is the kind of detail that would earn credit here.

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?

A single short sentence that front-loads the action and resource with no wasted words. It is appropriately sized, though the terseness leaves useful detail on the table rather than being maximally informative.

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

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

For a simple read-only tool with full schema coverage and no output schema, the definition is minimally adequate. However, since no output schema exists, the description should ideally convey what a 'photo' response looks like or that it may be absent — that gap keeps it from being complete.

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

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

Schema description coverage is 100%, so both spaceUid and accountUid (including the default-account fallback rule) are already documented in the schema. The description adds no syntax or semantic detail beyond the schema, so the baseline 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?

States a specific verb (Returns) and resource (the photo of a space), and clarifies that 'space' means a savings or spending space, which distinguishes it from adjacent siblings like get_savings_goal_photo and get_profile_image. It is clear, though it does not explicitly name the sibling it differs from.

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 on when to call this versus the many other image/photo siblings (get_savings_goal_photo, get_payee_image, get_profile_image) or on prerequisites such as whether a photo must exist. Usage is only implied by the name and resource.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered structurally. The description adds only the shape of the payload (balance, type, linked card) and says nothing about auth scope, error behavior, or whether the linked card may be absent.

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?

A single front-loaded sentence with zero filler, and the returned fields are parenthesised after the core action. It is efficient, though the extreme brevity leaves little room for the routing context an agent would benefit from.

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 two-parameter getter with full annotation coverage, the description is adequate. However, with no output schema, the return contract rests on three parenthetical field names and omits nullability of the linked card, so it is minimally complete rather than fully so.

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

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

Schema description coverage is 100%, with both spaceUid and the optional accountUid fully documented including the default-resolution rule, so the schema carries the parameter burden. The description contributes no additional parameter meaning beyond what the schema states, which is the baseline-3 case.

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 and resource ('Gets one spending space') and enumerates the salient returned fields (balance, type, linked card). It does not name or differentiate itself from the obvious sibling list_spaces, so it stops short of a 5.

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

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

Usage is only implied: 'one' signals single-record lookup versus the list_spaces sibling, but there is no explicit when-to-use, no mention of alternatives, and no statement of prerequisites. An agent must infer the retrieval-by-UID workflow.

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 readOnly, idempotent, non-destructive, openWorld, so safety is covered. The description earns credit for adding non-obvious semantic context: a null startDate means the order awaits review and a non-null cancelledAt means it is cancelled, which helps interpret the returned state.

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 compact sentences with the primary action front-loaded and the interpretive hints following. No filler and every sentence carries 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?

With no output schema, the description carries more of the burden, yet it supplies the key non-obvious state semantics (awaiting-review and cancelled). It stops short of describing the broader return shape, but is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema (accountUid and categoryUid even include defaults). The description adds nothing about parameters, so the baseline 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 states a specific verb and resource ('Gets one standing order'), and the word 'one' distinguishes it from list_standing_orders without needing to name the sibling. It does not, however, explicitly differentiate from get_payment_order, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus list_standing_orders, get_payment_order, or list_standing_order_upcoming_payments. The description offers no conditions, prerequisites, or alternative-selection logic, so the agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context by enumerating the returned metadata (scopes, expiry, consent expiry, UID) and the failure mode it diagnoses. No auth prerequisites or rate limits are stated, keeping it below a 5.

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, zero waste. The return contents are front-loaded and the diagnostic use case follows immediately. 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?

With no output schema, the description carries the burden of explaining return values, and it does so by listing the four fields. For a zero-parameter read-only introspection tool this is nearly complete; only the precise format of the returned values is left unspecified.

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 takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly makes no parameter claims.

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 and resource (returns the access token's granted OAuth scopes) and enumerates exactly what comes back: scopes, expiry, consent expiry, and account holder UID. This clearly distinguishes it from the account/transaction/payee siblings, which all deal with banking resources rather than token metadata.

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

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

Explicitly names the triggering scenario: 'Use this to diagnose 403 errors (missing scope).' That tells the agent precisely when to reach for it. It stops short of naming any alternative tool for the same diagnostic purpose, but no obvious sibling competes here.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds 'every detail', signalling a full-object return, but says nothing about pending vs settled feed items, pagination, or error behavior. Some added context, but modest.

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?

A single tight sentence with the identifying noun front-loaded. Efficient, though very short for a tool whose return shape is undocumented.

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

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

For a read-only single-record getter whose annotations cover safety and whose schema fully documents all three parameters, this is nearly sufficient. However, with no output schema, 'every detail' is the only hint about what comes back, so the agent cannot anticipate the response shape.

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

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

Schema description coverage is 100%, with accountUid and categoryUid defaults fully documented and feedItemUid clearly identified. The description adds no format or constraint detail beyond the schema, so baseline 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?

States a specific verb ('Gets') and resource ('a single feed item (transaction)'), and clarifies the domain term 'feed item' as 'transaction'. It implicitly contrasts with the many list_* siblings by saying 'single', but never names an alternative, so it stops short of a 5.

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

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

There is no when-to-use guidance and no exclusions. With siblings like list_transactions, list_settled_transactions, get_feed_changes_since, and get_card_transaction_details, the agent gets no help deciding which retrieval path fits a given request.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds a useful scoping note (only receipts submitted by this token), but says nothing about what the receipt contains 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?

A single front-loaded sentence with no padding. The parenthetical '(token)' is slightly awkward but compactly conveys the ownership scope.

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

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

For a simple read tool with full schema coverage and annotations covering the safety profile, the definition is largely sufficient. The absence of an output schema means a brief note on the receipt's contents would help, but nothing essential to invoking it correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters (including the required feedItemUid and the defaulting behaviour of accountUid/categoryUid) are already documented. The description adds no parameter meaning beyond the schema, so the baseline 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?

States a specific verb ('Gets') and resource ('itemised receipt') and scopes it to receipts 'this application (token) submitted', which separates it from generic transaction data. It does not explicitly name the sibling list_transaction_receipts, so differentiation is only implied by the singular form.

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 and no named alternative. An agent is not told how this differs from list_transaction_receipts or get_transaction, nor under what conditions to prefer 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered by structured data. The description adds non-obvious context the annotations do not carry: results are permission-scoped to the token, and defaultCategory is a dependency consumed by feed and payment endpoints. It omits pagination and any error/permission-failure behavior, keeping it short of a 5.

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?

A single front-loaded sentence with no filler: verb, scope, and payload fields in order of importance. Every clause earns its place, including the dependency note on defaultCategory.

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

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

With no output schema, the description correctly compensates by naming the returned fields and flagging the cross-endpoint dependency. It stops short of covering pagination/volume or what happens when the token has no accounts, which would round it out for a zero-parameter listing tool.

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

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

The tool takes zero parameters, so the baseline is 4 by rule. The description does not need to explain inputs; instead it usefully documents the shape of the returned objects, which is value beyond the empty 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 ('Lists') and resource ('accounts') plus the scope constraint ('this token can access') and enumerates the returned fields (accountUid, accountType, currency, name, defaultCategory). No sibling tool lists accounts, so an agent can distinguish it immediately from the get_* siblings without opening a 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?

Usage is only implied: the parenthetical notes defaultCategory is 'needed by feed and payment endpoints', which hints at a prerequisite role. There is no explicit when-to-use statement, no clarification of how this differs from get_account_balance or get_account_identifiers, and no guidance on when to prefer one account-access tool over another.

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, idempotentHint and non-destructive, so the safety profile is covered. The description adds real value by enumerating the returned control dimensions, but it does not disclose scope (all cards vs. filtered), ordering, or pagination behavior for a tool annotated openWorldHint.

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?

A single dense sentence that front-loads the purpose and then enumerates return content. It is long but every clause names a distinct field, so little is wasted; a bulleted split of the flag list would read slightly better.

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-param read with no output schema, the description does the heavy lifting by naming the returned fields, which is exactly what's needed. Minor gap: no statement of scope (all cards) or ordering, and no output schema means the agent learns return shape only from prose.

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?

Zero parameters, so the baseline is 4. The description correctly spends no words on inputs and instead documents the returned shape, which is the right allocation for a no-arg tool.

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

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

States a specific verb (Lists) and resource (the account holder's cards) and enumerates exactly what is returned (controls, flags, last 4, activation state). It is distinguishable from the many sibling list_* tools because it names the card-specific control domain.

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 when to use it (to inspect card controls and state) but gives no explicit when-not or alternative routing. No sibling is named even though get_card_transaction_details and list_accounts are plausible adjacents.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context the annotations do not carry: the default result set excludes cancelled mandates, and results can be narrowed by account. It stops short of describing pagination or result 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?

Three tight sentences, no filler, with the core purpose and returned fields front-loaded ahead of the filtering caveats. Efficient, though the field enumeration is a slightly long list for a single 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?

With no output schema, the description compensates by naming the returned fields (originator, reference, status, dates, amount, category), and it covers the default filter and account scoping. The unmentioned 'detail' parameter is the one notable omission for a 3-parameter tool.

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

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

Schema coverage is 67%; the description reinforces includeCancelled ('set includeCancelled to see cancelled ones') and accountUid, matching their schema descriptions with the added 'by default' nuance. The 'detail' enum parameter (compact/full) has no schema description and is never mentioned in the description, leaving a real 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?

States a specific verb and resource ('Lists direct debit mandates'), then disambiguates the concept with a parenthetical gloss ('who can take money by direct debit') and enumerates the fields returned. This clearly separates it from the singular get_direct_debit_mandate and from list_direct_debit_payments without requiring the agent to open either 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 gives behavioral guidance on default filtering ('Only LIVE mandates by default') and scoping ('Pass accountUid to restrict to one account'), which tells the agent how to call it. However it never states when to prefer this tool over siblings like get_direct_debit_mandate or list_direct_debit_payments, so the usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, covering the safety and idempotency profile. The description adds the per-mandate scoping constraint, which is useful, but does not describe pagination, ordering, or result limits. With annotations carrying the safety profile, 3 is appropriate.

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?

A single clause with zero waste, front-loading the verb and resource. 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 read-only list tool with full schema coverage and no output schema, the description plus annotations give an agent enough to call it correctly. It could be richer about return shape or pagination, but it is not required given the structured data.

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%: both mandateUid and since are documented with formats and patterns in the schema. The description only re-states that payments are scoped to a mandate and a start date, adding no syntax or format detail beyond the schema. Baseline 3 is correct when the schema does the heavy lifting.

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

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

Clear verb 'lists' and resource 'payments taken under a direct debit mandate', with a stated scope (since a date). It distinguishes itself from sibling mandate tools like get_direct_debit_mandate or list_direct_debit_mandates, which deal with the mandate itself rather than its payments. It falls short of 5 only because it does not explicitly name a sibling alternative to route the agent.

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 'since a date' phrase implies the tool is for retrieving a historical payment window, which is a usage cue, but there is no explicit when-to-use or when-not-to-use guidance and no mention of alternatives. Adequate minimum but with a clear gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description only adds the date-range scoping constraint; it says nothing about pagination, ordering, result limits, or auth requirements, which are the remaining behavioral gaps.

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

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

A single front-loaded sentence with no filler; the verb, resource, and scope constraint are all packed into one efficient statement.

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

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

For a simple read-only list tool whose annotations carry the safety profile and whose schema fully documents all parameters, the description is nearly sufficient. It could add ordering or pagination expectations, but nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, so all three parameters (payeeUid, payeeAccountUid, since) are already documented with patterns and formats. The description echoes the 'since a date' concept but adds no syntax or meaning beyond the schema, making 3 the correct baseline.

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 (lists) and resource (history of payments made to a payee account) with the scope constraint 'since a date'. It distinguishes itself from the scheduled-payments sibling by implying actual/historical rather than upcoming payments, though it never names a sibling explicitly.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The agent must infer from the name that this covers executed payment history versus list_payee_scheduled_payments or list_direct_debit_payments.

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 safety (readOnly, idempotent, non-destructive, openWorld), so the description is free to add genuinely new context: the compact-vs-full return shape and, importantly, that payments and standing orders are created from a payeeAccountUid exposed here. That relationship is not derivable from annotations or schema.

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

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

Three sentences, front-loaded with the primary action and return shape, followed by the relational context and parameter guidance. No filler or redundancy; every clause carries 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?

With no output schema, the description carries the return-value burden and does so by listing the row fields. Combined with annotations that fully declare the safety profile and a description that covers both parameters, the definition is nearly complete; only explicit sibling routing is missing.

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 50% – search is documented in the schema, but detail's enum values are not. The description compensates by explaining both modes ('one compact row' vs 'detail=full returns every field') and restates what search matches. Slightly above the baseline because the undocumented enum is clarified.

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 and resource ('Lists saved payees') and even enumerates the row content (name, payeeUid, payeeAccountUid, sort code/account number). The plural 'list' framing distinguishes it from the singular get_payee sibling, though no sibling is named explicitly.

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

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

Provides parameter-level usage hints ('use search to filter', 'detail=full returns every field') but never states when to choose list_payees over get_payee or how it relates to list_payee_payments. Usage is implied rather than scoped with alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety behavior needs no restating. The description contributes only the clarification that results cover future-dated and recurring items; no pagination or result-size context is added.

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?

A single, front-loaded sentence with the distinguishing qualifier in parentheses. No waste.

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

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

For a simple two-param read-only list tool with annotations and no output schema, this is minimally sufficient. It omits pagination/ordering behavior and how scheduled items are structured, which are modest gaps given the tool's simplicity.

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

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

Two parameters with 100% schema description coverage and enforced UUID patterns, so the schema carries parameter meaning. The description adds nothing about the parameters beyond the fact that they identify a payee and its account, which the baseline 3 reflects.

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 (Lists) and resource (scheduled payments) and disambiguates the scope with '(future-dated and recurring)'. This distinguishes it from list_payee_payments and find_recurring_payments conceptually, though it does not name any sibling explicitly.

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

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

No when-to-use guidance, prerequisites, or named alternatives. The scope parenthetical hints at the use case, but the agent must infer that this is the tool for upcoming/recurring payee payments rather than past ones.

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 establish the safety profile (readOnly, idempotent, non-destructive), so the description only needs to add context. It does usefully disclose ordering (newest first) and the possible status values plus 'reasons', which an agent cannot infer from annotations. Pagination/limit behavior is left to the schema.

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, zero filler, and the core purpose and return shape are front-loaded before the usage hint. 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?

With no output schema, the description must convey what comes back, and it does: payment records ordered newest first, with status and rejection reasons. Read-only semantics are covered by annotations, so nothing an agent needs to call this correctly is missing.

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 67%: paymentOrderUid and limit carry schema descriptions. The description adds no parameter-level meaning, and it never clarifies the undocumented 'detail' enum (compact vs full). Baseline 3 is appropriate since the schema does most of the work but leaves one 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?

States a specific verb+resource ('Lists the actual payments made under a payment order') with scope detail (newest first) and the returned status values. It is clearly distinguishable from the sibling get_payment_order, which would fetch the order itself rather than its underlying payments.

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

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

Explicitly says to use it after make_payment to confirm a payment went through, giving a concrete trigger condition. It stops short of stating when not to use it or naming a competing sibling for the same data, so it falls just below the top band.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds the returned field summary (total saved, target, percentage), which is genuinely useful context, but says nothing about pagination, ordering, 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?

A single short sentence with no filler, front-loading the verb and resource. 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?

With no output schema, the description compensates by naming the key fields returned. The tool is simple (one optional param), so little else is strictly needed, though the absence of any guidance on result shape beyond three fields or on routing to siblings is a minor gap.

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

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

Schema description coverage is 100% and the only parameter (accountUid) is fully documented in the schema, including its default resolution order. The description adds no parameter-level information, so 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?

States a specific verb ('Lists') and resource ('savings goals'), and usefully clarifies the synonym 'savings spaces'. It also names the returned fields. It does not explicitly distinguish itself from the singular get_savings_goal or from list_spaces, so it falls short of a 5.

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

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

There is no statement of when to use this tool versus get_savings_goal or list_spaces, and no prerequisites or exclusions. The plural name loosely implies 'list all', but the description supplies no actual routing 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, idempotentHint, non-destructive, and read-only safety. The description adds the settlement-time distinction and the 1-year max window, which is useful context. But it doesn't describe ordering, pagination, or result limits beyond what annotations provide.

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

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

Two sentences, front-loaded with the main action and scope, followed by a single justificatory clause. No filler, no repetition.

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

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

For a read-only list tool with a rich schema and full annotations, the description covers the key differentiator (settlement time) and a usage note. No output schema exists, so return shape is not explained, but for this tool type that is acceptable. Missing only explicit alternative-tool routing.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema (including the 'detail' enum and accountUid default behavior). The description adds the max 1-year constraint, which is not in the schema. That is a small but meaningful addition; baseline would be 3, and the constraint nudges it within that range.

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 (Lists), resource (settled transactions), and scope (whole account, all categories, settlement time window). Distinguishes from siblings like list_transactions by clarifying the settlement-time basis versus transaction time.

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?

Mentions 'useful for reconciliation' and explains why (card payments settle days after purchase), which implies when to use it. However, it does not name the alternative (list_transactions) or state when to prefer this tool over that one.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the "active" scoping (only active spaces are returned) and enumerates the fields returned per space type, which is genuinely useful since there is no output schema. It does not cover pagination or ordering.

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 tight sentences, front-loaded with the core action and scope, followed by the returned fields and the one actionable downstream hint. No filler or redundancy.

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

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

For a single-parameter read-only list tool with full schema coverage and no output schema, the description compensates well by enumerating what each returned space type contains (saved/target/% for savings, balance for spending). Only minor omissions remain, such as pagination or result ordering.

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 accountUid schema already documents the default-resolution behavior (STARLING_DEFAULT_ACCOUNT_UID / primary account). The description only alludes to "on an account" and adds no syntax or format meaning beyond the schema, so the baseline 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?

States a specific verb and resource ("Lists all active spaces on an account") and breaks the resource into its two subtypes, savings spaces and spending spaces, so an agent understands the scope without opening the schema. It partially disambiguates from siblings by equating savings spaces with savings goals, but never explicitly contrasts itself with list_savings_goals or get_spending_space.

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/when-not or named alternative. The closing note that "a space UID can be used as categoryUid for transactions and payments" implies a downstream purpose for calling the tool, which is useful context, but it is not selection guidance against the many sibling list_* 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 readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds a genuinely useful trait beyond them: it performs no API call, so the agent knows the result is static/local with no auth, latency or side effects. It could say more about result format.

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, zero filler, with the core action front-loaded and the operational caveat second. Nothing is repeated from the title or annotations.

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

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

With no output schema, the description does enough by stating that the full set of accepted category values is returned, which implies a flat list. It leaves the exact return shape (plain strings vs. objects, ordering) unspecified, a minor gap for an otherwise simple tool.

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

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

The tool takes zero parameters, so there is nothing to document and the schema is trivially complete. Baseline 4 applies; the description correctly spends no words on empty input.

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 precise verb+resource ('Lists every spending category value Starling accepts') and adds the reason it exists ('for filtering and recategorising'). No sibling tool returns this static enumeration, so there is nothing to disambiguate against.

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?

'For filtering and recategorising' tells the agent the situations that call for this tool's output, and 'Makes no API calls' signals it is a cheap lookup worth calling freely. It stops short of explicit when-not guidance or naming related sibling tools.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered; the description adds the meaningful default-filter behavior (active only, cancelled hidden, awaiting-review orders omitted) that annotations do not convey. It still says nothing about pagination or ordering of results.

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 with the resource and returned fields front-loaded, followed by the filter default and the exclusion. No filler and no repetition of the title.

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

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

With no output schema, the description usefully enumerates the returned fields, and it covers default filtering and the awaiting-review exclusion for a read-only list tool. Missing only the effect of the 'detail' parameter and any pagination/limit behavior.

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

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

Schema description coverage is 75%, and the schema already documents accountUid, categoryUid defaults and includeCancelled's default. The description reinforces the account/space scoping and the default-active semantics but never explains the 'detail' enum (compact vs full), leaving one parameter's effect undocumented in both places.

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 and resource ('Lists standing orders'), the scope (paid from the main account or a space), and enumerates the returned fields (payee name, amount, reference, schedule, next date). The plural naming plus 'get_standing_order' as a sibling makes the list-vs-single distinction obvious without opening either 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?

Gives clear operating context: results are active-only by default, includeCancelled widens the set, and orders awaiting review are excluded. It does not, however, route the agent between this tool and siblings such as get_standing_order or list_standing_order_upcoming_payments, so it stops short of full alternative 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that — no note on ordering of dates, pagination, or whether dates are truncated by the count limit — so it is minimum-viable against an already-rich annotation set.

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?

A single front-loaded sentence with the core purpose first and the parameter detail second; nothing is wasted. Slightly under-specified rather than verbose, but structurally sound.

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

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

For a read-only list tool whose annotations carry the safety profile and whose schema documents three of four parameters, the remaining need is small. No output schema exists, yet the description names the returned content (payment dates), so an agent has enough to call it correctly.

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

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

Schema coverage is 75% (accountUid, categoryUid, paymentOrderUid documented; count undocumented in the schema). The description fills that gap by supplying the count semantics (1 to 100, default 10), which is information the schema's minimum/maximum alone does not convey — the default in particular is new.

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 (Lists), resource (standing order), and the exact payload (next payment dates), which is distinct from get_standing_order's static definition and list_standing_orders' enumeration. It does not explicitly name those siblings, but the scope 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?

Usage is implied by the phrase 'next payment dates' — an agent can infer this is for forecasting future debits rather than inspecting the order itself. However, no alternatives (get_standing_order, list_standing_orders) or conditions/preconditions are stated, so it falls short of explicit when-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, covering the safety profile fully. The description adds only that the listed items are images/PDFs. With annotations carrying the behavioral load, this is adequate but not rich.

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?

A single, tightly scoped sentence with no filler. The core purpose is front-loaded in literally four 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 read-only listing tool with fully covered annotations and complete parameter schema, the description is nearly sufficient. It lacks only return-format context (e.g., whether attachment IDs are included for download_transaction_attachment), but without an output schema that is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the optionality and defaults for accountUid and categoryUid. The description adds no parameter meaning beyond the schema, so the baseline 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?

States a specific verb (Lists) and resource (files attached to a transaction), with a helpful parenthetical clarifying file types (images/PDFs). It is distinguishable from download_transaction_attachment and get_transaction_receipt, though it does not explicitly name siblings.

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

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

No guidance on when to use this tool versus alternatives like download_transaction_attachment or get_transaction_receipt. An agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, covering the safety profile. The description adds a genuinely useful behavioral detail beyond the annotations: receipts come 'from any source (you, Starling, or partners)', which tells the agent to expect heterogeneous data. It does not describe return format or pagination, so it earns a moderate 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?

A single tight sentence with the resource front-loaded and zero filler. Nothing can be removed without losing information.

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

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

For a read-only list tool whose annotations carry the safety profile and whose schema is fully documented, the description is nearly sufficient. It states what is returned ('all itemised receipts'), leaving only minor gaps around result shape and whether multiple receipts can exist per transaction.

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

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

Schema description coverage is 100%, with all three parameters fully documented including defaults for accountUid and categoryUid. The description only implies that feedItemUid maps to 'a transaction', adding no meaningful semantics beyond the schema, so the baseline 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?

States a specific verb (gets) and resource (all itemised receipts for a transaction), and the plural 'all' implicitly contrasts with the singular get_transaction_receipt sibling. However, it never names that sibling or otherwise explicitly differentiates the two, leaving the distinction to inference.

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 offers no when-to-use guidance, no prerequisite conditions, and no mention of alternatives such as get_transaction_receipt or list_transaction_attachments. It simply restates the operation without helping the agent decide when this tool is the right pick.

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 establish the read-only, idempotent, non-destructive profile, yet the description adds substantial behavior: 1,000-per-page paging, that ranges up to a year cost a single request, signed amounts in compact rows, per-currency totals, and a prompt-injection warning about third-party text. This is exactly the added context the annotations cannot convey.

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?

Front-loaded with the core purpose, then defaults, cost/paging, amount sign convention, return totals, and a safety note. Every sentence earns its place with no redundancy; density is high but justified for a 13-parameter tool.

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

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

With no output schema, the description steps up to explain returns (compact vs full rows, signed amounts, per-currency in/out totals) and paging semantics. Combined with full schema coverage, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so the parameter definitions carry most of the load, making 3 the baseline. The description still adds interpretation the schema lacks — that compact amounts are signed (negative = out), that the query returns per-currency totals, and that long ranges page automatically — which meaningfully informs parameter behavior.

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

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

States a specific verb (Lists) plus resource (transactions/feed items), scope (main account or a space), and ordering (newest first), so the agent knows exactly what it returns. It doesn't explicitly differentiate from close siblings like list_settled_transactions, get_feed_changes_since, or export_transactions_csv, which prevents a 5.

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

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

Gives useful context about defaults (last 30 days) and the automatic paging threshold, which implies when it's appropriate. But it never says when to prefer this over list_settled_transactions, get_feed_changes_since, or export_transactions_csv, so alternative selection is left 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 the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lower, yet the description adds real context: local analysis, the default inclusion/exclusion set (settled + pending, excluding internal space moves), and a request-limit constraint for long ranges. It stops short of mentioning pagination or auth requirements.

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

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

Two dense sentences: purpose first, defaults second, with the request-limit note as a trailing qualifier. No sentence is wasted and every clause carries operational 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 an 8-parameter, all-optional tool with no output schema, the description covers purpose, grouping semantics, defaults and range constraints well. It only lightly indicates the returned shape (the 'in/out/net' hint) and gives no sense of result structure for the other groupings.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds genuine meaning beyond the schema: the month grouping returns 'in/out/net' (which the schema never states, and which explains why direction is ignored), and it clarifies counterparty means merchant/payee. That is additive semantics rather than restatement.

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