Run my Accounts MCP by usefulapi

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the underlying endpoint (GET /customers/{customernumber}), which is mildly useful context, but says nothing about behavior on a missing customer (error vs empty) or the shape of the returned record.

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 the core purpose front-loaded and no filler. The endpoint reference is arguably redundant with the tool name but is compact and earns marginal value for developers.

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

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

For a one-parameter read-only lookup with full schema coverage and no output schema, the description covers what the agent needs to call it correctly. The only real gap is not hinting at the returned customer fields or not-found behavior, which is a minor omission at this complexity.

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

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

Schema coverage is 100% and the single parameter already carries a description with an example ('K-001'), so the schema does the heavy lifting. The description only restates that the parameter is the customer number, adding no format or lookup nuances.

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 ('Get one customer') plus the lookup key ('by customer number'), which is more precise than the sibling list_customers. It does not explicitly name the list sibling as an alternative, but the singular/plural contrast is self-evident.

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 can infer this is for fetching a single known customer rather than enumerating them, thanks to 'one' and the required customer number. No explicit when-to-use/when-not statement or named alternative 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, so the safety profile is covered. The description adds real value beyond that by disclosing the response content — the invoice arrives with its customer and line items embedded — which matters given there is no output schema. It omits error behavior (e.g. what happens for an unknown invoice number) and any auth/prerequisite notes.

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 padding. The purpose and payload are front-loaded before the endpoint detail, which is the right order for a reader scanning for relevance.

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 annotations covering safety, the definition covers purpose, lookup key and returned shape. A note on not-found behavior or on whether payments are included would close the remaining small 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 single required parameter is documented with an example ('R-002'), so the description does not need to restate it. The API path template reinforces that invoice_number is the lookup key, but adds no syntax or format detail beyond what the schema already gives. 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 ('Get one customer invoice') and names the embedded data ('customer and line items'). The word 'one' plus 'customer' implicitly separates it from runmyaccounts_list_invoices and runmyaccounts_get_vendor_invoice, though neither sibling is called out by 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?

Usage is only implied by the singular 'one customer invoice' phrasing. There is no explicit statement of when to use this lookup versus list_invoices (for enumerating) or get_vendor_invoice (for the payable side), 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 readOnlyHint=true so the safety profile is known. The description adds the underlying API endpoint (GET /payables/{invoice_number}), which is mildly useful context, but says nothing about auth requirements, error behavior for unknown invoice numbers, or response shape. With annotations covering safety, this meets the lower bar but adds little.

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, front-loaded with the operation and immediately followed by the endpoint. 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 full schema coverage and a readOnly annotation, the definition is nearly complete. It lacks only a brief note on what the returned invoice object contains or what happens if the number is not found, hence not a 5.

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 sole parameter is documented with an example ('K-001'), so the description need not explain it further. The phrase 'by invoice number' mirrors rather than extends the schema, making 3 the appropriate 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 ('Get one vendor invoice') with an explicit lookup key ('by invoice number'), which distinguishes it from the sibling list_vendor_invoices and from runmyaccounts_get_invoice by resource type. An agent can identify the intended operation 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 single-item scope implies when to use it (known invoice number vs. listing), but there is no explicit when-to-use guidance, no exclusions, and no named alternative such as list_vendor_invoices. Usage is inferable rather than 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's burden is lower. It adds the underlying API endpoint and wildcard semantics, but says nothing about result ordering, pagination, or volume of transactions returned for an all-accounts wildcard, which is the main behavioral risk 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?

Two tight sentences: the core purpose and wildcard rule come first, followed by the endpoint reference. 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?

For a read-only list tool with a fully described five-parameter schema and no output schema, the definition covers what to call and how to scope it. The remaining gap is what the response looks like and how many rows an all-accounts wildcard may return.

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 the date bounds and closing/opening toggles) are already documented. The description restates the accno wildcard rule and adds the "x matches any digit" detail, a small value-add over the schema's 10xx example, but nothing beyond 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 and resource ("List ledger transactions of one account") plus the wildcard scope, so an agent can distinguish it from the chart/customer/invoice siblings. It does not explicitly name a sibling it supersedes, which keeps it 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 parenthetical "use x for all accounts" gives a concrete usage pattern for the wildcard, which is helpful guidance. There is no explicit guidance on when to prefer this over sibling tools such as trial_balance or list_payments_since, so usage context 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?

readOnlyHint=true already declares this a safe read, so the description only needs to add context; the GET /charts endpoint reference is a small addition. It says nothing about pagination, result ordering, or whether the chart is hierarchical, which are the traits an agent would actually want beyond the annotation.

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 short sentences, front-loaded with the purpose, then the optional filter, then the endpoint. The endpoint line is marginal for invocation but useful for debugging; nothing else 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 a one-parameter read tool with readOnlyHint and full schema coverage, the essentials are present. With no output schema, though, the description never indicates what an account record contains or how many come back, leaving a real gap for result handling.

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 optional parameter is documented there, so the baseline of 3 applies. The description restates the filter's purpose but adds no allowed values, case sensitivity, or behavior when the filter is omitted.

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 ("List the chart of accounts"), which is unambiguous against siblings like list_customers or list_invoices. It does not, however, explicitly differentiate itself from trial_balance, the other accounting-structure sibling.

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?

"Optionally filter by account type" hints at one usage pattern but gives no when-to-use criteria, no prerequisites, and no pointer to alternatives such as runmyaccounts_trial_balance for balance-oriented questions. The agent must infer when this is the right call.

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, so the safety profile is covered. The description adds the underlying endpoint (GET /customers) and the field set returned, but says nothing about pagination, result size, ordering, or whether all records are returned unbounded.

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 sentence plus the endpoint reference, with the core purpose front-loaded and zero filler. Nothing could be cut 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 is the only source of return-shape information, and it only names fields rather than their structure. Missing details on pagination and whether the list is exhaustive are material gaps for a list-all 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 for the description to disambiguate; the baseline for a parameterless tool applies. The listed return fields give useful context about what the call yields.

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 ('List all customers') and enumerates the returned fields (number, name, address, contact, bank data). It does not explicitly distinguish itself from the sibling 'runmyaccounts_get_customer', though the list-vs-get contrast is reasonably inferable.

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 can infer this is for enumerating the full customer set rather than fetching one. There is no statement of when to prefer this over get_customer, nor any note about filtering or scope limits.

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 readOnlyHint annotation already establishes this is a safe read. The description adds the underlying HTTP endpoint, which is minor context, but says nothing about whether results are paginated, sorted, cached, or limited in size.

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

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

Two short, front-loaded sentences with no filler. The endpoint reference is arguably redundant for an agent but costs little.

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

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

For a zero-parameter read-only list with no output schema, the description is adequate but does not hint at the shape of returned department records (id, name, type) or result volume. An agent knows what to call but not quite 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 the schema burden is nil and the baseline is 4. The description correctly implies no filtering inputs are needed by stating a plain list over /departments.

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 ('List departments') and clarifies the domain meaning as cost and profit centers, which an agent can map to accounting concepts. It is distinguishable from siblings only by resource name, without explicit differentiation from similar list tools like list_projects.

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 list semantics, but there is no statement of when to use this versus other list tools (list_projects, list_charts) or what the results are typically needed for. No exclusions or prerequisites 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?

Annotations already declare readOnlyHint=true, so safety is covered. The description adds the backing endpoint, but says nothing about pagination, result limits, or what a payment record contains.

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, purpose front-loaded, endpoint detail trailing. 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?

No output schema exists, and the description doesn't indicate what the returned payment objects look like or whether the list is paginated/bounded, leaving an agent partially uninformed about results.

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?

Single required parameter with 100% schema coverage, so the schema already defines invoice_number. Only one param, so baseline 4 applies per rule; description adds no extra semantics 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?

Specific verb and resource: lists payments booked against one customer invoice, which distinguishes it from runmyaccounts_list_vendor_invoice_payments by qualifying 'customer'.

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?

Implies you need an invoice number to fetch its payments, but gives no when-to-use vs runmyaccounts_list_payments_since (the broader time-based sibling) or runmyaccounts_get_invoice.

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?

readOnlyHint=true already establishes the safety profile, so the description's main extra contribution is the underlying endpoint (GET /invoices), which quietly confirms it is a non-mutating read. It adds nothing about pagination, result volume, or whether the date defaults are applied server-side, leaving modest gaps for a read 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?

Three short clauses, purpose front-loaded, no filler. The trailing 'API: GET /invoices' is marginally useful for developer-style consumers but is the least essential 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?

The tool is simple (4 optional params, no output schema, read-only) and the schema plus annotations fill most needs. However, with no output schema, the description should hint at the returned invoice shape or ordering, which it does not.

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%, including the important 'OPEN includes due and overdue' nuance, so the schema already carries the semantic load. The description restates the same filter dimensions without adding format or interaction details, 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+resource ('List customer invoices') and enumerates the filter dimensions, so the agent knows exactly what it retrieves. The 'customer' qualifier implicitly separates it from runmyaccounts_list_vendor_invoices, but 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?

No guidance on when to use this versus runmyaccounts_get_invoice or runmyaccounts_list_invoice_payments, and no mention of defaults or preconditions beyond the filter list. The agent must infer the calling context 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, so the safety profile is covered. The description usefully discloses the returned field set (number, description, unit, price, account numbers) and the underlying endpoint, but says nothing about result size, pagination, or whether all parts are returned — relevant gaps for a list endpoint with 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 compact sentences, front-loading the resource and returned fields, with the endpoint as a trailing technical note. 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 parameters and no output schema, the description carries the return-value burden and does so by listing the exposed fields. Missing only secondary details such as volume, ordering, or pagination behavior, which keeps it short of a 5.

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. The description correctly signals a parameter-free call by noting only the resource and endpoint, leaving nothing for the agent to misunderstand.

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 ('List parts'), disambiguates the domain term with a synonym ('articles'), and enumerates the fields returned. It does not explicitly distinguish itself from siblings like runmyaccounts_list_charts or runmyaccounts_list_customers, 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?

There is no guidance on when to use this tool versus the other list_* siblings, no prerequisites, and no exclusions. The only implicit help is the 'parts (articles)' synonym mapping that helps an agent recognize the 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=true, so 'this tool only reads: it never marks a payment as processed' largely restates the annotation, though the specific reassurance about not changing processing state is mild added value. The description adds the backing endpoint (GET /invoices/payment_list?processed=) for traceability but says nothing about result size, ordering, or pagination.

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 short sentences, front-loaded with the scope and immediately followed by the read-only guarantee. The endpoint line is arguably low-value for an agent but is compact and harmless.

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

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

For a one-parameter read tool whose annotations already cover the safety profile, the description covers invocation but there is no output schema and no statement of what a returned payment record contains (fields, ordering, volume), leaving a real gap for an agent planning to consume results.

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 'processed' parameter documents its own yyyy-MM-ddTHH:mm format and pattern. The description's 'after a time stamp' adds the comparison semantics but no format or edge-case 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?

Names a specific verb and resource ('List incoming invoice payments') and narrows the scope to payments 'not marked as processed' after a timestamp, which distinguishes it from the unfiltered sibling runmyaccounts_list_invoice_payments. It does not explicitly call out that sibling, so the differentiation is inferable 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?

The phrase 'not marked as processed after a time stamp' implies the reconciliation/bookkeeping use case, but there is no explicit 'use this when...' guidance and no named alternative (the sibling list_invoice_payments is never mentioned). Usage must be inferred from the scope clause.

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?

readOnlyHint=true already tells the agent this is a safe read, and "GET /projects" only corroborates that. The description does not disclose return shape, pagination, whether all projects are returned or whether results are filtered by account/workspace context — behavior an agent needs to use the result correctly.

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, front-loaded with the action, with zero padding or repetition beyond the title. It is arguably too terse rather than verbose, which is penalized under completeness rather than here.

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 beyond readOnlyHint, the description is the only place to explain what a project record contains or how results are scoped. It settles for restating the name plus an endpoint, leaving the agent to discover the return shape at call time.

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 no parameters, so the baseline is 4; there is nothing for the description to compensate for. It correctly implies no filtering inputs are accepted.

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 ("List projects") and names the backing endpoint GET /projects, so an agent knows exactly what the tool returns. It does not need sibling differentiation since no other tool in the list touches projects, but it also gives no scope detail (all projects? paginated?).

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 alternatives, nor any preconditions. For a zero-parameter list tool the choice is fairly obvious from the name, but the description itself supplies nothing an agent could not infer from the title.

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?

readOnlyHint=true already declares the safety profile, so the description only needs to add context. It adds the per-invoice scoping and the underlying endpoint, but says nothing about pagination, ordering, or what an empty result means for an invoice with no payments.

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 purpose front-loaded and no filler. The trailing API route line is mildly developer-oriented and adds little for an agent deciding whether to call the 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?

For a single-parameter read tool with annotations and no output schema, the definition covers what is needed to invoke it correctly. A brief note on the returned payment fields or result ordering would close the remaining 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?

With one parameter at 100% schema coverage, the schema already documents invoice_number. The phrase 'one vendor invoice' usefully reinforces that this is a vendor (not customer) invoice number, but no format, example, or lookup hint is added.

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

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

States a specific verb (list) and a precisely scoped resource (payments booked against one vendor invoice), which implicitly separates it from runmyaccounts_list_invoice_payments and runmyaccounts_list_payments_since. No sibling is named explicitly, so differentiation is inferred from the 'vendor invoice' qualifier 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?

The description never says when to use this versus runmyaccounts_list_payments_since (date-based) or the customer-invoice counterpart, nor does it state prerequisites such as needing a valid invoice number first. Usage is only inferable from the tool's purpose.

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, so the safety profile is covered. The description adds useful context on the shape of results (status, amounts, paid amount, vendor) but says nothing about pagination, result limits, or default filtering — notable for a list endpoint that accepts no parameters.

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 front-loads the purpose and the returned fields. The trailing 'API: GET /payables' is mildly redundant but harmless for an agent mapping to the backend.

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?

A parameterless list tool with annotations covering read-only and no output schema; naming the returned fields largely substitutes for the schema. Missing guidance on ordering, result volume, or how to narrow results means an agent cannot predict what a full call returns.

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. The mention of returned fields is extra, not required.

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 ('List vendor invoices') and clarifies the domain with '(payables)' plus the returned fields. It does not explicitly distinguish itself from the sibling runmyaccounts_list_invoices (customer invoices), which is the main ambiguity an agent would face.

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 versus runmyaccounts_list_invoices, runmyaccounts_list_vendor_invoice_payments, or runmyaccounts_get_vendor_invoice. The '(payables)' parenthetical implies scope but gives no selection criteria or 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?

readOnlyHint=true already establishes this is a safe read, so the description's main addition is the underlying endpoint GET /vendors. It does not disclose pagination behavior, default sort order, or result-size limits — meaningful gaps for a list operation, but not contradictory to the annotations.

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

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

Two short sentences with the purpose front-loaded, followed by capability and endpoint. The sort/search enumeration largely duplicates the schema verbatim, a small amount of redundancy, but nothing is buried or 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?

For a two-optional-parameter read tool with full schema coverage and no output schema, the definition covers how to call it. It falls short on what comes back (record fields, whether all vendors are returned, pagination), which an agent needs to plan a listing 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?

Schema description coverage is 100%, so both parameters are already documented in the schema, including the sort pattern. The description restates the same sort fields and search-by-name behavior with an example, adding essentially no meaning beyond the structured data; 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 ("List vendors") and adds the accounting synonym "(creditors)", which helps an agent map business language to the tool. It is distinguishable from siblings such as runmyaccounts_list_customers by the resource name, though it never explicitly contrasts with get_vendor or the customer 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?

Usage is only implied by the presence of sort and query controls; there is no statement of when to use this versus a detail lookup or other list tools, nor any precondition. An agent can infer "browse/search the vendor directory" but nothing more.

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 readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful context—version, API endpoint, wildcard filtering, and the from/to requirement for income statement accounts—but it does not describe the response format, grouping, pagination, or default behavior beyond what the schema provides.

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 four short sentences and front-loads the purpose before usage details. Every sentence carries useful information: the resource, wildcard syntax, a conditional date requirement, and the underlying API endpoint.

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?

All eight parameters are fully documented in the schema, and the description covers the key invocation constraints. Because there is no output schema, the description could say more about the returned balance structure, but it is sufficient for an agent 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 the baseline is 3. The description adds a meaningful cross-parameter rule that income statement accounts need from and to, plus a wildcard example for accno, which goes beyond the individual 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: 'Get account balances (trial balance, version 2).' That is clearly distinct from sibling tools that list transactions, customers, invoices, projects, or charts, so an agent can identify the right tool without opening the schema.

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

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

It gives concrete usage guidance for filtering ('Use x as a wildcard in accno') and a conditional requirement ('Income statement accounts need from and to'). It does not explicitly say when to prefer this over alternatives such as list_account_transactions, but the report-oriented context is clear.

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