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

No annotations exist, so the description carries the full burden. It documents the return fields but says nothing about authentication, error behavior when the account ID is invalid, or whether field values may be null/optional.

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, front-loaded with the action and followed by the return payload, with no filler.

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

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

For a single-parameter read tool with no output schema, the description supplies the full field list, which is genuinely useful. Minor gaps remain around error/auth behavior, but the operational core is complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only repeats that the ID identifies the account and adds no format or constraint detail beyond the schema's 'Mercury account UUID'.

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 (Retrieve) and resource (Mercury account) scoped by account ID, and it enumerates the returned fields, making it clearly distinguishable from siblings like get_accounts or get_account_statements.

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

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

The description implies usage via 'by its account ID' and by contrasting with the list-oriented sibling get_accounts, but it never states when to use this tool versus alternatives or any prerequisites.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses return contents (card type, status, cardholder information) but says nothing about permissions, rate limits, or whether the operation is read-only (though the verb 'Retrieve' implies a read).

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

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

Two sentences with no waste; the purpose is front-loaded and the return contents are stated succinctly.

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 operation with one parameter and full schema coverage, the description is adequate but lacks behavioral context that annotations would normally provide. It does specify return contents, which is helpful since there is no output schema, but it omits any usage guidance.

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 accountId parameter with its UUID format. The description adds no parameter detail beyond this, but with full schema coverage and only one parameter, the baseline is 4.

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

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

States a specific verb (Retrieve) and resource (debit and credit cards for a Mercury account), plus the scope (associated with a specific account). Clearly distinguishable from siblings like get_account_statements or get_accounts, which deal with different resources.

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

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

The description implies usage by specifying a required accountId, but gives no explicit when-to-use guidance or alternatives. No sibling differentiation or exclusions are mentioned.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the returned fields, status and type enums, and cursor-based pagination, but does not mention permissions, rate limits, or explicitly confirm that the operation is read-only and non-destructive.

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 front-loaded with purpose, then provides the return shape and pagination behavior. Every sentence earns its place, especially the return-field enumeration given the absence of an output schema.

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 four optional parameters and no output schema, the description covers the essential call context: purpose, returned fields, and pagination mechanics. It stops short of describing authorization requirements or behavior when no accounts match, but 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 description coverage is 100%, so the schema already documents limit, order, start_after, and end_before. The description reinforces cursor-based pagination with start_after and end_before but adds little meaning beyond the schema's own parameter descriptions.

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

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

The description states a specific verb and resource: retrieve a paginated list of all Mercury accounts for the organization. It also scopes the tool by listing return fields and distinguishing it from single-account siblings like get_account through the word 'all' and 'list'.

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 explains what the tool does but gives no explicit guidance on when to use it versus alternatives such as get_account or get_treasury_accounts. Usage is only implied by the resource name and pagination 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?

With no annotations, the description carries the full burden and does add real context: the returned fields (downloadUrl, startDate, endDate, endingBalance, accountNumber, EIN), the account-type eligibility restriction, and the 3-month range limit. It stops short of disclosing auth requirements, rate limits, or pagination behavior, which keeps 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?

Three front-loaded sentences: purpose first, then return payload, then the exclusion and range constraints. Every sentence carries operative information and there is no filler.

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

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

No output schema exists, but the description enumerates the returned fields, and no annotations exist to cover constraints, so the description must carry that load — which it largely does. The remaining gap is pagination/cursor behavior for end_before/start_after, which is left to the schema.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents accountId, start, end, limit, order, and paging cursors. The description adds a constraint not present in the schema (the 3-month maximum range for start/end), which meaningfully augments the 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?

States a specific verb and resource ('Retrieve monthly statements') and scopes it to 'a specific Mercury account'. It explicitly contrasts with the sibling get_treasury_statements and rules out treasury/credit accounts, so an agent can distinguish it 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?

Gives an explicit when-not-to-use ('treasury and credit accounts are NOT supported'), names the alternative tool to use instead, and states a hard usage constraint (max 3-month range via start/end). This is exactly the when/when-not/alternatives guidance required.

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

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

No annotations are provided, so the description carries the full burden. "Retrieve" implies a safe read, and the list of returned fields adds real transparency about the response shape, but nothing is said about permissions, error behavior, or whether the org is inferred from the current credential.

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 purpose, then a compact enumeration of return fields in a single sentence. No wasted words; the field list is dense but useful rather than filler.

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

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

With no output schema and no annotations, the description substitutes by enumerating the returned fields (EIN, DBA default flag, organization kind, UUID), which is exactly what an agent needs. It stops short of describing auth or default-org resolution, a minor gap.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly implies no inputs are needed, though it does not explicitly state that the organization is selected from the current session/credential.

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 (Retrieve) and resource (the Mercury organization) and enumerates the exact fields returned (EIN, legal name, DBAs, kind, UUID). No sibling tool covers organization data, so it is unambiguous among the listed get_* tools.

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

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

Usage is implied by the description for a zero-parameter lookup, but there is no explicit statement of when to call this versus the sibling get_account/get_recipient tools or of any prerequisite (e.g., authentication or an org context). Adequate but with clear gaps.

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, so description carries the burden. It enumerates the returned fields, functioning as a return-value disclosure. However no permissions, rate limits, or read-only semantics are stated. Partial coverage.

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

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

Two efficient sentences, front-loaded with purpose then return contents. The field enumeration is borderline verbose but serves a purpose without an output schema.

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

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

No output schema, so listing return fields is valuable and compensates well. But guidance on usage, error conditions (invalid ID), and behavioral traits are missing for an otherwise simple lookup.

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 (recipientId) is fully described as a UUID in the schema. Description adds nothing beyond the schema's parameter documentation, so 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 (retrieve) and resource (payment recipient) with a clear scope qualifier (by their ID). Distinguishes from the sibling list/get_recipients which handles collections.

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 vs get_recipients or list_transactions. The 'by their ID' phrasing implies single-record retrieval but no explicit when-to-use or exclusion criteria are given.

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

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

No annotations are provided, so the description carries the full burden. It does disclose pagination and enumerates returned fields and their value domains (e.g., defaultPaymentMethod options, status active/deleted), which is useful return-shape context. However, it omits auth requirements, rate limits, and any behavior around deleted recipients, leaving meaningful gaps for an unannotated tool.

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

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

Two sentences, front-loaded with the operation and followed by a compact list of return fields. Every sentence earns its place: the first establishes purpose and pagination, the second describes the response shape. No filler.

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

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

With no output schema, the description usefully enumerates the returned fields, which is important for a list tool. The input schema is fully described. What prevents a 5 is the absence of guidance on pagination cursor usage, default inclusion of deleted recipients, or auth context, though these are minor for a read-only list.

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 input schema already fully documents limit, order, start_after, and end_before. The description adds no parameter-level syntax or constraints beyond what the schema provides. A baseline 3 is appropriate 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?

The description states a specific verb and resource: 'Retrieve a paginated list of all payment recipients.' This clearly distinguishes the operation as a bulk list, but it does not explicitly name the singular sibling get_recipient as the alternative for fetching one recipient. So the purpose is clear but sibling differentiation is left implicit.

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 explicit guidance on when to use this tool versus alternatives like get_recipient or the other list/get tools. It implies usage through 'list of all payment recipients,' but lacks any when-to-use, when-not-to-use, or prerequisite 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?

No annotations are provided, so the description carries the full disclosure burden. It helpfully enumerates the returned fields (id, amount, status, etc.), which compensates for the missing output schema, but it says nothing about auth requirements, error behavior for an unknown/invalid ID, or read-only/safety characteristics.

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, purpose first, return shape second. The field enumeration is long but earns its place because there is no output schema to document the response.

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 no output schema, the description supplies both the lookup semantics and the full return-field list, which is what an agent needs. Only error/permission behavior is left unaddressed, 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% ('The Mercury transaction UUID'), so the schema already documents the sole parameter. The description only restates that lookup is by transaction ID and adds no 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 ('Retrieve') and resource ('a single Mercury transaction') plus the lookup key (transaction ID), which lets an agent distinguish it from list_transactions/list_account_transactions by cardinality. It does not, however, explicitly name those siblings as the alternative.

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: 'by its transaction ID' signals a single-record lookup versus the list_* siblings, but there is no explicit when-to-use/when-not guidance or named alternative. The agent must infer the routing from the name and cardinality.

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 burden. It discloses returned fields (balances, status enum, netReturns breakdown) which is useful, but says nothing about pagination behavior despite limit/start_after/end_before parameters, nor auth requirements or read-only nature. For a list tool with zero annotations this is a significant gap.

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 core purpose followed by returned fields. Efficient with no filler, though the return-field list borders on output documentation that could live in an output schema.

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

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

The description covers purpose and return fields, which is reasonable for a simple list tool. However, with no annotations, no output schema, and pagination parameters present, it omits pagination behavior and usage context, leaving meaningful 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%, so the schema already documents all four parameters (limit, order, end_before, start_after) with ranges, defaults, and semantics. The description adds no parameter-level detail beyond what the schema provides, 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 (Retrieve) and resource (Mercury treasury accounts) scoped to the organization. Distinguishes from siblings like get_treasury_transactions and get_treasury_statements by naming the account resource, though it doesn't explicitly contrast 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?

No guidance on when to use this tool versus alternatives such as get_accounts or get_treasury_transactions. The description implies a read/list operation but provides no context about when a caller would pick it over related tools.

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

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

With no annotations, the description carries the full burden. It helpfully enumerates return fields (downloadUrl, periodStart, periodEnd, documentType, description, creationDate), which discloses the response shape, but it never states that this is a read-only operation, whether pagination is cursor-based, or any permission requirements.

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

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

Two sentences, front-loaded with the core action, followed by return fields and filter values. No filler and nothing buried.

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 compensates by listing the returned fields. The only shortfall is that cursor-based pagination semantics (start_after/end_before) are left entirely to the schema, but overall the definition is sufficient to call the tool correctly.

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

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

Schema description coverage is 100%, so all six parameters are already documented, including the documentType enum and the cursor fields. The description merely repeats the documentType enum values the schema already provides, adding no new format or constraint detail.

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 (Retrieve) and resource (statements) scoped to a 'specific Mercury treasury account', which cleanly separates it from siblings like get_account_statements and get_treasury_transactions. An agent can pick it 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 implied by the resource and the documentType filter, but there is no explicit when-to-use guidance or comparison against alternatives such as get_account_statements. Nothing routes the agent when both could plausibly apply.

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 burden. It discloses pagination behavior (integer cursor, not UUID-based), lists returned fields (amount, balance, canonicalDay, description, transaction type), and enumerates transaction types. It does not mention authentication requirements, rate limits, or whether results are filtered by default, but it adds substantial context beyond a basic read operation.

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

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

The description is two sentences, front-loaded with the core purpose, and the pagination note is placed as a secondary detail. It is efficient without unnecessary padding, though the transaction type enumeration is somewhat verbose.

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

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

For a read-only tool with no annotations and no output schema, the description covers the essential aspects: what it retrieves, the return fields, transaction types, and the pagination mechanism. It is nearly complete but does not address potential error conditions or permissions, which are minor 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%, so the schema already documents all four parameters (limit, order, cursor, treasuryId). The description mentions 'integer cursor pagination,' which reinforces the cursor parameter's type but adds no new semantic detail beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Retrieve') and resource ('paginated transactions for a specific Mercury treasury account'), which is distinguishable from generic siblings like list_transactions or get_transaction. However, it does not explicitly differentiate from similar sibling tools such as get_treasury_accounts or list_account_transactions, leaving some ambiguity.

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

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

The description implies usage for retrieving treasury account transactions but provides no explicit guidance on when to use this tool versus alternatives like list_transactions or get_transaction. There is no 'when not to use' or alternative specification.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses pagination behavior and the exact trimmed return fields, but says nothing about permissions/auth, default date window behavior, or read-only nature, so disclosure is partial.

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 purpose, then filters, then return shape in three tight sentences. The return-field enumeration is somewhat long but genuinely informative given there is no output schema, so it earns its space.

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 9-parameter list tool with no output schema, the description compensates well by listing return fields and pagination, and filters are covered by the schema. The main gap is the absence of any routing guidance against the many sibling list/get tools.

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

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

Schema coverage is 100%, so both schema and description fully document the 9 parameters. The description only restates the filter categories (date range, status, search, merchant category) without adding format or default details beyond what the schema already gives (e.g., YYYY-MM-DD, default windows). 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 ('Retrieve a paginated list of transactions') scoped to 'a specific Mercury account', which is more precise than the generic sibling list_transactions. It stops short of naming that sibling or get_transaction to differentiate directly, so an agent must infer the split.

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 or alternatives are given. The sibling set contains list_transactions, get_transaction, and get_treasury_transactions, but the description never says which to pick or under what conditions; the only usage signal is the implicit 'specific account' scope.

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

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

No annotations are provided, so the description carries the full burden. It discloses that only custom categories (not built-in ones) are returned and that IDs and names are included, which is useful. However, it omits whether this is a read-only operation, any pagination behavior, or permission requirements.

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

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

Three sentences with zero padding; the distinction from built-in categories is front-loaded, followed by return-value clarification and downstream use. Every sentence earns its place.

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

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

For a zero-param list tool with no output schema, the description covers what the tool returns (IDs and names) and how they are used. The absence of pagination and auth information is a minor gap but not critical for a simple enumeration 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?

There are zero parameters, so per rubric the baseline is 4. The description also provides no misleading parameter info, keeping it at 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?

States a specific verb ('Retrieve') and resource ('all available custom expense categories') with scope ('for the organization'). Explicitly distinguishes from built-in mercuryCategory classifications, making it clearly separate from the list_transactions family.

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?

Explains the downstream use case by noting the returned IDs can filter transactions via the categoryId parameter. This gives clear context for why to call it, but does not name exclusion conditions or a strict 'when not to use' alternative.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose the returned payload fields (available credit, balances, account status), which is useful, but says nothing about permissions required, pagination, or result limits for what is presumably an unbounded list.

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 tightly written sentences, front-loaded with what the tool does, followed by return-value information that earns its place because no output schema exists. Zero filler.

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

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

For a parameterless, read-only list tool with no annotations and no output schema, the description covers purpose and return contents adequately. It would be fully complete with a note on pagination/scale and any permission requirements.

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 and the schema is empty, so there is nothing for the description to clarify. Baseline 4 applies; no parameter-related omissions exist.

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 gives a specific verb+resource ('Retrieve all credit accounts') and scopes it to 'the organization', which separates it from single-account siblings like get_account. It does not explicitly distinguish itself from get_accounts or get_treasury_accounts, 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?

There is no statement of when to use this tool versus alternatives such as get_accounts or get_treasury_accounts, and no prerequisites or exclusions are given. The scope ('all ... for the organization') only implicitly signals usage.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses cursor-based pagination and that results are trimmed transaction objects, but omits permissions/auth needs, rate limits, and what 'trimmed' actually excludes. Partial but real added context beyond 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, front-loaded with the verb and scope, followed by a compact enumeration of filters. The middle clause is dense and comma-laden but each element maps to a real parameter, so little 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?

For an 11-parameter list tool with no output schema, the description should explain the return shape more concretely; 'trimmed transaction objects' leaves the agent guessing what was removed. Pagination is mentioned but cursor semantics are only in the schema, making this adequate rather than 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 every parameter is already documented with formats, ranges, and defaults. The description merely enumerates the same filter names without adding format rules or interaction semantics, 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 (Retrieve) and resource (transactions) with scope (across all accounts) and notes advanced filtering capability. However, it never names or contrasts with the close sibling list_account_transactions, so differentiation rests on the reader noticing 'all accounts' versus the sibling's account scoping.

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, and no reference to alternatives. With siblings like list_account_transactions, get_transaction, and get_treasury_transactions present, the agent gets no help deciding which to call; usage is only implied by the 'all accounts' phrasing.

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