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

There are no annotations, so the description carries the full burden of disclosing side effects, but it only says 'Add a note...' It does not clarify whether the note appends to existing notes or replaces them, whether the operation is reversible or idempotent, or what authorization or response behavior to expect. This leaves the agent uncertain about the mutation's exact effects.

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

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

One short, front-loaded sentence with no filler. It states the operation and target in a single clear phrase, so 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 simple two-parameter tool, the input model is clear and fully schematized. However, with no annotations and no output schema, the definition leaves gaps about the mutation behavior and expected result, making it workable but not fully self-sufficient.

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

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

Schema description coverage is 100% and both `transaction_id` and `notes` include meaningful descriptions, so the schema already documents the parameters. The tool description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

States a specific verb ('Add') and resource ('a note to a transaction's metadata'), so an agent knows exactly what this operation does. It is clearly distinct from sibling tools that list/get/search transactions or move money into/out of pots.

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

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

The description implies the use case: use this tool when a note needs to be attached to a transaction's metadata. However, it does not explicitly state when not to use it or name alternatives, leaving the guidance implicit 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?

Since no annotations are provided, the description must disclose behavioral traits, but it does not. It fails to state that this is a write operation, that it will alter account and pot balances, or that it may have side effects like fees or reversibility. The verb 'move' vaguely implies a state change but offers no detail on consequences, making it dangerously opaque for a financial mutation.

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 concise sentence that front-loads the action and resource. No filler or redundant phrasing; 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 money-moving tool with no output schema and no annotations, the description is underspecified. It omits critical context such as that the operation debits the source account and credits the pot, potential failure modes (e.g., insufficient funds, invalid pot), or whether confirmation is returned. An agent may not anticipate these outcomes.

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 (pot_id, account_id, amount_pounds) already described. The tool description adds no additional meaning about parameter relationships or format beyond the schema, so it meets the baseline for high coverage without adding value.

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

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

The description states a clear verb ('move') and resource ('money from an account into a Monzo pot'), making the tool's purpose immediately obvious. It also differentiates from the sibling withdraw_from_pot by specifying direction, so an agent can distinguish without opening the schema.

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

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

No guidance is given on when to use this tool relative to alternatives. There's no mention of prerequisites, conditions for depositing, or a pointer to withdraw_from_pot for the reverse operation. The agent is left to infer usage solely from the tool name and 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Get' implies a read operation and suggests the tool does not modify data, but the description does not state that explicitly. It also doesn't clarify what kind of balance is returned, in what units or currency, or whether pending transactions are included.

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 clear sentence with no filler or irrelevant details. It is front-loaded and concise, though it could have packed in more useful guidance about behavior or return value without becoming bloated.

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

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

The tool is simple with one well-documented required parameter, so the description is minimally adequate for invocation. However, with no output schema and no annotations, the description should say more about what 'balance' means (available/current/cleared), the units/currency, and that account_id is likely obtained from list_accounts. These gaps prevent 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 coverage is 100%, and the schema already describes account_id as 'The Monzo account ID to inspect'. The tool description adds no additional parameter context, but because the schema fully documents the only parameter, the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Get') and a specific resource ('the balance for a Monzo account'), so an agent can tell this is a read-only balance lookup rather than a transaction or account listing tool. It is not maximally detailed because it doesn't clarify whether this is the available, current, or cleared balance, nor does it explicitly differentiate from siblings, but the core purpose is unambiguous.

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

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

The description gives no guidance about when to use this tool instead of siblings like list_accounts or list_transactions. It also doesn't mention that account_id comes from list_accounts or any prerequisite/context. The intended usage is only implied by the tool name and description, not stated.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Get' implies a read operation, but the description does not explicitly state that it has no side effects, what the return format is, or how errors are handled. It adds little beyond the action itself.

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 clear sentence with no filler words. It conveys the essential purpose and scope efficiently, and every element earns its place.

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

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

For a simple one-parameter get-by-ID tool, the description is adequate but not complete. There is no output schema and no description of the return structure; it also does not guide the agent on how this tool relates to list_transactions or search_transactions.

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

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

Schema coverage is 100% and the single parameter transaction_id is already described as 'The transaction ID to fetch'. The description does not add meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Get'), the resource ('a specific Monzo transaction'), and the scope ('full details'). The word 'specific' distinguishes this from sibling list/search tools, so an agent can tell it apart without opening the schema.

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

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

The description implies this tool is for fetching one transaction by ID, especially given the required transaction_id parameter. However, it does not explicitly say when to use it versus list_transactions or search_transactions, nor does it mention any 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states scope ('available to the user'); it does not mention authentication requirements, whether the operation is read-only, what fields are returned, or any ordering/pagination 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?

The description is a single short sentence with no filler and the core action is front-loaded. It is appropriately sized for a zero-parameter listing 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?

For a simple read-only list with no parameters, the description is minimally viable. However, since there is no output schema and no mention of what fields are returned or how account IDs are used by downstream sibling tools, an agent cannot fully predict how to consume 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?

The input schema has zero parameters and 100% coverage, so there is nothing for the description to add about parameter meaning or formats. This matches the baseline for a parameterless tool.

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

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

The description uses a specific verb ('List') and resource ('Monzo accounts') and adds a useful scope qualifier ('available to the user'). This clearly distinguishes it from sibling tools that operate on balances, transactions, or pots.

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 or implicit guidance about when to choose this tool over siblings such as get_balance or list_transactions, and no prerequisites or exclusions are mentioned. An agent would have to infer that listing accounts is the natural first step before account-scoped calls.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explicitly state that this is a read-only operation, nor does it describe what happens with an invalid account_id, whether results are paginated, or what pot properties are returned. The verb 'List' implies non-mutation, but this is not an explicit disclosure.

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, direct sentence that front-loads the action and resource. Every word is necessary and there is no filler, redundancy, or over-specification.

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

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

For a simple one-parameter list tool, the description covers the core action, but it omits expected return shape (no output schema) and does not tell the agent how to source a valid account_id. The absent output schema suggests the description should mention what a 'pot' listing contains; this is a clear but non-critical gap.

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

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

The input schema already documents the sole parameter account_id with a descriptive comment, giving 100% coverage. The tool description adds no extra parameter semantics beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses an active verb (List) with a specific resource (Monzo pots) and clear scope (linked to an account). It is immediately distinguishable from sibling tools like list_accounts, which return accounts, and deposit/withdraw tools, which modify pots.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites such as obtaining a valid account_id from list_accounts, nor does it say when a different tool would be more appropriate. The description only states the action, not the context.

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

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

With no annotations, the description is the only behavioral signal. It communicates that this is a read ('List') operation but does not disclose ordering semantics of 'recent', pagination behavior beyond the schema default, or any account-access expectations.

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. Every word contributes to identifying what the tool does, and the key action and object appear 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?

Despite a four-parameter schema and no output schema, the description says nothing about default behavior, interpretation of 'recent', or how this differs from search_transactions. An agent is left without enough context to choose it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains account_id, limit, since, and before. The description adds no parameter semantics beyond labeling the list as 'recent'.

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

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

The description uses the specific verb 'List' with a clear resource ('recent transactions for an account'), so an agent can tell what the tool targets. However, it doesn't explicitly distinguish this from sibling search_transactions or get_transaction, 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 or when-not-to-use guidance. With a sibling named search_transactions, the description should state whether list_transactions is for simple recent listings and search is for filtered/advanced queries, but it leaves that entirely 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the matching fields and does not describe result shape, ordering, pagination, matching semantics (e.g., substring vs exact), or any other runtime behavior beyond 'search'.

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

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

The description is a single front-loaded sentence with no filler words. Every word contributes: the action, the resource, and the search criteria are all immediately visible.

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 and no annotations, the description omits information an agent would need to use the tool effectively, such as return format, pagination, or ordering. It also lacks routing guidance relative to list_transactions, making the overall tool description incomplete for a 4-parameter search 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 the baseline is 3. The description adds value by clarifying that the 'query' parameter is matched against merchant or description text, which is not explicitly captured in the schema's generic 'Case-insensitive text to match' description.

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

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

The description uses a specific verb ('Search'), names the resource ('transactions'), and states the search criteria ('by merchant or description text'). This clearly distinguishes it from sibling tools like list_transactions, which would list rather than text-search.

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

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

The description implies the tool is for finding transactions by text, but it does not explicitly say when to prefer this tool over list_transactions or get_transaction, nor does it mention any exclusions. Usage context is inferable but not stated.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states a money-moving mutation but does not mention prerequisites, side effects, reversibility, failure modes, or whether the transfer is internal-only.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every word adds meaning and it is appropriately sized for the 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?

For a mutation tool with no annotations and no output schema, this one-line description is too thin. It lacks information about prerequisites, expected response, and edge cases, leaving an agent to infer important operational details.

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 parameters are already well documented. The description adds no extra parameter meaning, but the schema's property descriptions are sufficient to reach the 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?

The description uses a specific verb and resource: 'Move money from a Monzo pot back into an account.' It clearly identifies a transfer operation and is unambiguous about direction, though it does not explicitly name or contrast the sibling deposit_to_pot.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that deposit_to_pot is the inverse operation or that list_pots/list_accounts may be needed first to obtain valid IDs.

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