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

With no annotations, the description carries the full burden. It does not disclose that this is a submission/mutation-style operation, whether a request is queued or a report is returned immediately, whether anything is sent to the merchant, or whether it can be repeated. Only the incidental 'free' hint adds any context.

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

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

A single short sentence with no filler, and the tool's subject is front-loaded. It is arguably under-specified rather than verbose, but it is cleanly structured and wastes no tokens.

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 four-parameter submission tool with no annotations and no output schema, the description says almost nothing about process, outcome, or return behavior. An agent cannot tell what happens after calling it or how to interpret success.

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 four parameters documented and two enums enumerated in the schema itself, so the baseline of 3 applies. The description adds no additional meaning about the url, category, delivery, or description fields beyond what the schema already states.

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

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

The description names an action ('Ask for') and a resource ('Revenue & Pricing Audit'), so the general intent is inferable, but 'ask for' is vague about whether this submits a request, generates a report, or just returns a link. It also gives no differentiation from the sibling agenta_audit_show, which an agent could easily confuse with this one.

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

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

There is no statement of when to use this tool versus agenta_audit_show or any of the other audit-related siblings, and no prerequisites (e.g., that a merchant URL is required, or that this is a submission/request flow). The only guidance is the word 'free', which is not actionable selection criteria.

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, yet it never states that this writes a file to disk (a side effect that fires by default given download=true), what permissions are needed, or what happens when no report exists. Only the conditional 'once it exists' adds any behavioral context.

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

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

The text is brief and front-loaded, but it succeeds by omission rather than concision: the missing verb makes the sentence ungrammatical and ambiguous, which is under-specification rather than economy.

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 annotations and no output schema, the description must explain the tool's read-and-download behavior, but it leaves the core question open (what audit state is returned, and is the download an unavoidable side effect). The fully covered two-parameter schema keeps this from being worse than merely inadequate.

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 (output, download) are already fully documented in the schema, including the default path and the terminal-vs-tool-call distinction. The description adds nothing beyond restating the download condition, so the baseline 3 applies.

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

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

The fragment names resources ('audit state', 'report PDF') but omits its primary verb, so it's unclear whether it retrieves state, downloads a file, or does both. It does not distinguish itself from the obvious sibling agenta_audit_request or the adjacent agenta_status_get, leaving the agent to guess.

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 'once it exists' hints that a prior audit must have been requested, but there is no explicit when-to-use guidance and no mention of agenta_audit_request as the precursor or of how this differs from agenta_status_get.

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, yet it says nothing about pagination behavior, ordering, whether the list is scoped to the authenticated account, or auth requirements. 'List customers' is only a restatement of the 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?

Two words are maximally concise and front-loaded, but this brevity reflects under-specification rather than disciplined editing. There is no wasted text, yet nothing is earned either.

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 list endpoint with no annotations and no output schema, the description should at least indicate what is returned and how pagination works. As written, an agent gets no behavioral context beyond the operation name.

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 'limit' parameter is fully documented in the schema ('Results per page, default 10, max 100'). The description adds no parameter meaning, so the baseline of 3 applies.

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

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

The description states a clear verb and resource ('List customers'), which is more specific than a bare restatement of the name. However, it gives no scope, filtering, or differentiation from sibling list tools such as agenta_invoices_list or agenta_subscriptions_list, so an agent cannot tell which list endpoint applies.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives. The agent must infer usage entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about read-only safety, pagination behavior, result ordering, or return shape, though the parameter name implies paging. For a zero-annotation tool this is a substantial 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 words with zero filler and the verb front-loaded, so there is no wasted text. But the terseness comes at the cost of usefulness rather than reflecting deliberate concision.

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 annotations, no output schema, and a description this thin, the agent must infer everything about the result set (pagination metadata, ordering, tenant scoping). For an invoice-listing tool in a multi-tenant API, the description falls short of 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%, so the single 'limit' parameter is already fully documented in the schema with default and min/max. The description adds nothing beyond the schema, which is the baseline 3 for a fully covered 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 and resource ('List invoices'), so the basic operation is unambiguous. However, it offers no scope detail (whose invoices, what filtering, what ordering) and nothing that distinguishes it from sibling invoice tools such as agenta_invoices_receipt. Vague-but-adequate.

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 versus the other invoice siblings (receipt, send_receipt) or versus other list tools (customers_list, products_list, pay_list). The description provides no context or exclusions at all.

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 burden and does disclose a key behavioral precondition: the invoice must be paid. However, it says nothing about error behavior for unpaid invoices, authentication requirements, or how the download is delivered (stream vs. saved file), leaving meaningful gaps.

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

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

A single sentence with zero wasted words, and the key constraint ('paid invoice') is front-loaded alongside the action. Appropriately sized for a simple 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 low-complexity download tool with full schema coverage and no output schema, the description covers what is produced and the main precondition. It is nearly complete, though a note on failure behavior for unpaid invoices 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?

Schema description coverage is 100%, so both parameters (id and output path) are already documented in the schema. The description adds no additional syntax, format, or usage detail for either parameter, making the baseline 3 appropriate.

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

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

The description states a specific verb ('Download'), resource ('receipt PDF'), and scope ('for a paid invoice'), making the action unambiguous. It does not explicitly differentiate from the sibling 'agenta_invoices_send_receipt', but the download-vs-send distinction is implicit in the verb.

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

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

There is no when-to-use guidance, no prerequisites beyond the paid-invoice constraint, and no mention of alternatives. The description implies you call it when you want a receipt, but offers no routing logic against sibling tools.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It does not say whether the send is idempotent, whether it fails when no buyer email exists, whether it requires permissions, or what the caller observes on success.

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

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

One short sentence with zero padding and the action front-loaded. It is efficient, though the terse size leaves substance unstated rather than adding value.

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 side-effecting tool with no annotations and no output schema, the description is minimally adequate but omits failure modes and observable effects of triggering an email. An agent can call it, but cannot predict what happens if the invoice lacks a buyer address.

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 a single 'id' parameter already documented as 'The invoice id', and the description adds no further format or source details. When the schema does the heavy lifting, a 3 baseline 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 (re-send) and resource (the receipt email) plus the recipient (buyer on file), so the action is unambiguous. It is reasonably distinguishable from the sibling agenta_invoices_receipt, though it never explicitly contrasts the two.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the sibling agenta_invoices_receipt (likely the fetch-an-existing-receipt counterpart). The 're-send' prefix faintly implies a prior send happened, but nothing guides tool selection.

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, yet it discloses nothing beyond the bare action. It does not say whether this mutates state, requires authentication or an API key, whether the session is reusable/expires, or what the caller receives back.

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 single sentence is front-loaded and free of waste, stating the action immediately. It is arguably too terse for a payment tool, but it is structurally clean.

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 payment checkout-creation tool with no annotations, no output schema, and four parameters, a single four-word sentence is inadequate. The agent is not told what a checkout session is, what it returns (e.g. a checkout URL), or how it fits with the pay_get/pay_list siblings.

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 (email, amount, currency, description) with examples. The description adds no additional meaning beyond what the schema provides, which is the baseline expectation 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?

States a specific verb ('Create') and resource ('checkout session'), so the agent understands the action. However, it makes no attempt to distinguish itself from siblings like agenta_pay_get or agenta_pay_list, relying entirely on the tool name for 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 guidance on when to use this tool versus alternatives, no prerequisites, and no mention of the payment flow it initiates. The agent must infer usage 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the basic action and does not reveal whether the operation is read-only, requires authentication, has rate limits, or what errors may occur, leaving significant behavioral gaps.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is appropriately sized for a simple status-retrieval tool and 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?

The tool is simple: one required parameter fully described in the schema, no output schema, and no annotations. The one-line description covers the basic purpose but omits usage context and behavioral details that would help an agent understand when and how to rely on it, making it minimally 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 the single parameter 'sessionId' is fully documented in the schema itself. The description adds no additional meaning about the parameter, which is acceptable given the schema's completeness and yields a baseline score of 3.

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

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

The description states a specific verb ('Get') and resource ('checkout session status'), making the tool's basic function clear. It does not, however, distinguish this tool from siblings such as agenta_pay_list or agenta_pay_checkout, so it falls short of the sibling differentiation required for 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 description offers no explicit guidance on when to use this tool versus alternatives like agenta_pay_list or agenta_pay_checkout. While the phrase 'checkout session status' implies a retrieval use case, there are no stated conditions, prerequisites, or exclusions to help an agent choose correctly.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it supplies almost nothing. 'List' implies a read-only operation, but there is no mention of pagination behavior, result ordering, auth requirements, or what a returned checkout session 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?

Three words with zero padding and the action front-loaded, so there is no waste. But the brevity here is under-specification rather than disciplined concision, which caps the score.

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

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

For a simple two-optional-parameter list tool with 100% schema coverage, the description is minimally adequate to select the tool. With no output schema, though, it would have been useful to state what a listed checkout session looks like or how results are paginated.

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

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

Schema description coverage is 100%, with both 'limit' and 'status' (enum) fully documented inline, so the schema does the heavy lifting. The description adds no meaning beyond the schema, which is the expected baseline when coverage is complete.

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 clear verb and resource ('List checkout sessions'), which is enough to distinguish this list operation from mutation siblings like agenta_pay_checkout. However, it does nothing to differentiate itself from the closely related agenta_pay_get, which an agent could easily confuse for the same resource.

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 alternatives such as agenta_pay_get or agenta_pay_checkout, nor any mention of prerequisites or filtering context. The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden and discloses almost nothing: no auth requirements, no side effects, no indication that this provisions a payable object linked to checkout. 'Create' implies mutation, but reversibility, idempotency, and post-creation state are all unstated.

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

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

A single front-loaded sentence with the two modes stated immediately and zero filler. Nothing in it is redundant or misplaced.

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 nine-parameter mutation tool with no annotations and no output schema, the description is thin: it never explains how subscription/interval/trialDays interact, nor what the caller receives back on success. Adequate to identify the tool, insufficient to call 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 every parameter (amount, currency, interval, trialDays, successUrl, cancelUrl, subscription, description) is already documented in the schema. Baseline 3 applies because the description adds no additional parameter meaning beyond what the schema provides.

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 (Create) and resource (product) and disambiguates the two output modes: one-time product vs subscription plan. It does not explicitly contrast itself with siblings such as agenta_products_list, but the intent is unambiguous 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?

Usage is implied by the create verb, but there is no guidance on when to choose a one-time product versus a subscription, nor any mention of prerequisites or the relationship to agenta_subscriptions_change_plan. The agent must infer the selection condition from the 'subscription' and 'interval' parameters.

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, yet it says nothing about this being a read-only operation, pagination behavior, rate limits, or auth requirements. For a list tool the safety profile is low-risk, but the agent gets no behavioral context at all.

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?

Four words is front-loaded and waste-free, but it is terse to the point of under-specification rather than genuine conciseness. Nothing about scope or return shape is included to earn the brevity.

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 one optional parameter, no output schema, and no annotations, the description should at minimum clarify what is returned and whether results are paginated. It supplies none of that, leaving the agent under-informed about the call's behavior and output.

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 'limit' parameter is fully documented in the schema, so the baseline of 3 applies. The description adds nothing about the parameter, but it does not need to.

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

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

It names a verb (List) and a resource (products), so the basic action is inferable, but 'and plans' leaves it ambiguous whether this returns two distinct entity types, a combined catalogue, or a products list annotated with plan info. There is no differentiation from siblings such as agenta_subscriptions_list or agenta_products_create.

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

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

The description offers no when-to-use guidance, no prerequisites, and does not mention any alternative tool for related listing needs (subscriptions_list, invoices_list, pay_list). The agent must infer the use case purely from the name.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses almost nothing: no indication of read-only safety, authentication/account-scoping requirements, freshness or caching of the go-live state, or what 'go-live' even means operationally. The 'get'-style name mildly implies a read, but that is inference, not 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?

A single front-loaded phrase with zero padding or redundancy. It is efficient, though at six words it veers toward under-specification rather than ideal brevity; there is no structural waste to penalize.

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 tool with no output schema and no annotations, the description is the only source of information about the response, yet it never says what fields come back or how to interpret the account/go-live result. An agent can call it but cannot judge what it will receive or when the result is actionable.

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 (empty object schema, 0 required), so per the rubric the baseline is 4. There is nothing for the description to add on the input side, and no missing parameter documentation to compensate for.

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 phrase names the resource domain (account) and one aspect (go-live), so an agent can infer this is a read of onboarding/account status. However it is a bare noun phrase with no verb and no differentiation from siblings like agenta_verify_status, which plausibly also reports a status. The purpose is implied rather than stated.

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

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

There is no when-to-use guidance, no stated prerequisites, and no mention of alternatives such as agenta_verify_status, agenta_verify_declaration, or agenta_customers_list. The agent is left to guess whether this is a pre-checkout readiness call or a general account snapshot.

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 one key trait—cancellation happens at period end by default—but omits irreversibility, required permissions, billing effects, and what happens to access after cancellation.

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

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

A single front-loaded sentence with zero waste. The most important information—the action and its default timing—appears immediately.

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

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

Given no annotations and no output schema, the description should do more for a destructive cancel operation. It covers purpose and default timing but leaves critical context gaps around consequences, reversibility, and permissions.

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 both parameters. The description adds value by explicitly stating that period-end cancellation is the default, clarifying the effect of leaving the 'now' parameter unset.

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 ('Cancel a subscription') and adds the default timing. This clearly distinguishes it from sibling tools like agenta_subscriptions_list and agenta_subscriptions_change_plan without needing to name them.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The parenthetical states a default behavior, but does not address when immediate cancellation is appropriate or what conditions warrant cancellation.

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 key billing semantics: upgrades charge immediately and downgrades take effect at period end. That is meaningful beyond the schema, though it omits permission requirements, reversibility, and response behavior.

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

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

A single short sentence, front-loaded with the action and resource, with zero filler. The parenthetical adds the one behavioral nuance that matters most.

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?

Given 100% schema coverage and no output schema, the description supplies the essential mutation behavior and billing timing. It could mention dryRun or response shape more directly, but for a three-parameter plan-change tool the core information is present.

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

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

The schema already documents all three parameters at 100% coverage, including id, to, and dryRun. The description only implies the 'to' field via 'another plan' and adds no format or constraint details 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 ('Move') and resource ('subscription') and identifies the target as 'another plan', which differentiates it from cancel/list siblings in the toolset. It does not name any sibling or explicitly contrast, so not 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 purpose makes the general use case obvious, and upgrade/downgrade timing hints at behavior, but there is no explicit when-to-use guidance or comparison to sibling tools like subscriptions_cancel. No exclusions or prerequisites are 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 burden of behavioral disclosure, and it discloses nothing: no pagination behavior, no auth requirements, no return shape, no statement of what a 'subscription' contains. Two words cannot cover a read operation's 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?

It is a single short phrase with zero waste and is front-loaded, but its brevity stems from under-specification rather than disciplined editing. There is nothing to restructure, and nothing to trim either.

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 annotations, no output schema, and no description of the returned subscription records or pagination, the definition is not complete enough for an agent to know what it will receive. The only adequately documented element is the limit parameter, covered by 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?

There is a single parameter (limit) with 100% schema description coverage, including default and min/max bounds, so the schema already does the work. The description adds no additional meaning, which matches the baseline 3 for high-coverage schemas.

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 verb and resource ("List subscriptions"), so the agent knows the operation type, but it is essentially a restatement of the tool name and says nothing about scope (whose subscriptions, any filters, account-level vs. plan-level). It does not differentiate from siblings like agenta_subscriptions_cancel or agenta_subscriptions_change_plan beyond the obvious verb.

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 versus the other subscription or list tools (agenta_customers_list, agenta_invoices_list, etc.), nor any prerequisites. The agent must infer everything 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether this is a read or write action, not what a 'declaration' verification does, not what state it changes, and not what it returns.

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?

It is short, but this is under-specification rather than conciseness. The one fragment is not front-loaded with any actionable purpose, so it fails the 'every sentence should earn its place' test.

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 tool with no annotations and no output schema, the description must explain what the tool does and what to expect. It supplies neither, leaving an agent with no way to invoke this correctly within the verification workflow implied by its siblings.

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

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

The schema defines zero parameters, so there is nothing for the description to clarify; the baseline of 4 applies. The description adds no parameter meaning but none is needed.

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

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

The description is a cryptic sentence fragment: 'The five statements --accept-declaration attests to'. It gestures at subject matter related to a declaration but never states a verb+resource for this tool, so an agent cannot tell what agenta_verify_declaration actually does or how it differs from siblings like agenta_verify_submit or agenta_verify_status.

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, when-not-to-use, prerequisites, or alternative is mentioned. The sibling set contains several verify_* tools, and the description gives no basis for choosing among them.

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 for what is clearly a state-changing action. It does not say what state is created or altered, whether it notifies the reviewing party, whether it can be undone, or what happens on failure — 'send back for review' is the only behavioral hint.

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

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

A single short sentence with no filler, and the trigger condition is placed after the action, which is acceptable for a one-liner. It is efficient, though its brevity borders on under-specification rather than polish.

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 but state-mutating tool with no annotations and no output schema, the description should at least state prerequisites and the effect of a successful resubmission. None of that is present, so an agent cannot verify it is taking the right action.

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; the baseline of 4 applies.

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

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

The verb phrase 'Send back for review' gestures at resubmitting a verification, and 'after making the changes we asked for' adds the resubmission nuance not present in the name. However it never says what object is being re-sent (a verification submission?) and does not differentiate itself from the sibling agenta_verify_submit, which an agent could easily confuse it with.

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?

'After making the changes we asked for' is an implied trigger condition and is the one thing the description does well. But it never names the alternative (agenta_verify_submit) or states when this should NOT be used, leaving the submit-vs-resubmit routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it delivers nothing. It does not state whether the call is read-only, what authentication or verification context is required, or what happens when no verification exists.

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

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

At six words it is short, but this is under-specification rather than conciseness. The fragment is front-loaded yet conveys almost no actionable information, similar to the 'Process' failure mode.

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 annotations and no output schema, the description should at minimum explain what status information comes back, but it says nothing about return shape, progress states, or error conditions. For a simple zero-param tool this is inadequate rather than fatal.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The empty schema is self-consistent with a status-lookup 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 phrase 'Where the verification has got to' essentially restates the tool name (verify_status) in colloquial form without a clear verb or resource scope. It does not distinguish this tool from the sibling agenta_status_get, which an agent could easily confuse it with. This is closer to a tautology than a specific purpose statement.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related alternatives (agenta_verify_submit, agenta_verify_resubmit, agenta_status_get). An agent is left to guess the invocation context entirely.

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

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

With no annotations, the description carries the full behavioral burden and does not meet it. It does not say whether submission is idempotent, what happens on failure, what the merchant must do to be eligible, or how it relates to the resubmit path; only the downstream business outcome is disclosed.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably too thin for an 18-parameter submission tool, a shortfall better attributed to completeness than to verbosity.

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 18-parameter submission tool with zero required parameters, no annotations, and no output schema, the description leaves critical context unaddressed: whether all fields are truly optional, what triggers a resubmission instead, and what the caller gets back. It is not sufficient to invoke this tool correctly on first try.

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 (including the four enums and their allowed values) is already documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Submit business verification') and adds the business outcome ('so the merchant can accept live payments'), which helps an agent understand intent. However, it does not distinguish this tool from its close siblings agenta_verify_resubmit or agenta_verify_declaration, which are all in the same verification 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?

There is no guidance on when to call this versus agenta_verify_resubmit (e.g., first submission vs. after a rejection) or whether agenta_verify_declaration must be run first. The 'acceptDeclaration' parameter hints at a prerequisite tool, but the description never states it.

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