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

No annotations are provided, so the description carries the full burden, and it does substantial work: discloses that this takes a business live on a real payment institution (UniPaaS rails, FCA-authorised), that onboarding is progressive KYB, that it returns an account + access/keys, and that it will optionally create a payable checkout. What it omits is the operational profile of a live-account-creating mutation: idempotency, whether re-invocation creates a duplicate merchant account, failure/retry behavior, and whether the live action is reversible.

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

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

Front-loaded with the core action and the sibling-composition in the second half, with no structural waste. It is somewhat dense and carries marketing phrasing ('the fastest path to accept payments, get paid') that could be trimmed, but nearly every clause carries routing or behavioral information.

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

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

For a 6-param, no-annotation, no-output-schema tool that performs a high-stakes live onboarding, the description covers what is created, where (paas.build / UniPaaS rails), the compliance path (progressive KYB), and what comes back (account + access). Remaining gaps are the unlabeled env/region/currency parameters and duplicate-account/idempotency behavior.

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

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

Schema coverage is 50%: email, input, and amount are documented in the schema, and the description adds useful mapping for two of them ('business name/website/description' -> input, 'first payable checkout' -> amount). The other three (env, region, currency) are undocumented in both schema and description, so the description does not compensate for the coverage gap and baseline 3 applies.

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

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

States a specific verb+resource ('Add payments to an app') and immediately names the concrete actions: identifies the business from name/website/description, takes it live on paas.build, returns an account + access, optionally creates a checkout link. It also explicitly positions itself as a composite of identify_business + go_live (+ create_checkout), so an agent can tell it apart from those siblings without opening any schema.

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

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

Gives explicit trigger phrases ('add payments', 'accept payments', 'let me get paid') and names the class of alternatives it replaces (Stripe / Stripe Connect / Paddle), plus the fact that it bundles identify_business + go_live. It does not say when to prefer the granular siblings (go_live alone, create_subscription_* for recurring billing), which is the only routing gap.

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

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

No annotations are provided, so the description carries the disclosure burden alone. It does disclose the key output (a payable shortLink) and the go_live prerequisite, but says nothing about link expiry, idempotency, sandbox-vs-production effects, or whether the access_token will be enforced — meaningful gaps for a payment-creating mutation.

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

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

Two tight sentences, zero filler, with the core action and return value front-loaded before the prerequisite and use cases.

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?

Adequate for a 6-parameter mutation: the go_live prerequisite and the shortLink return are covered and the schema handles most field detail. But with no annotations and no output schema, the missing guidance on choice versus create_subscription_checkout and on link lifetime/enforcement of access_token leaves real holes.

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 83%, so the schema already documents env, amount units, currency default, reference, and the access_token hint. The description adds no parameter-level meaning beyond what those field descriptions already say, so the baseline 3 applies.

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

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

States a specific verb and resource — 'Create a hosted checkout / payment link to charge a customer' — and even names the return value (payable shortLink). It stops short of distinguishing itself from the sibling create_subscription_checkout, and mentions 'subscription' in its own usage line, which blurs the boundary.

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

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

Gives an explicit precondition ('The vendor must already be live (go_live)') and concrete scenarios ('accept a payment, sell a product or subscription, or send someone a pay link'). No exclusion rules — an agent still has to guess when create_subscription_checkout is the better choice.

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 at all, the description carries the full behavioral burden and does most of it well: it discloses that real money moves on the first cycle, that the card is stored, and that billing auto-renews – the three facts an agent most needs before a destructive financial call. It omits failure modes, idempotency/retry behavior, and what state the subscription lands in if the initial charge fails.

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

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

Two sentences, both loaded: the first covers the action and its billing consequences, the second covers return values, and a trailing clause covers ordering. No filler, and the most decision-relevant facts (charge + auto-renew) are front-loaded.

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, and the description correctly fills that gap by naming the two return artifacts (shortLink for hosted, sessionToken for embedded). For an 8-parameter, 6-required financial mutation it still leaves the meaning of several required inputs and the failure path unaddressed, but the core call-shaping 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?

Schema coverage is only 50%, and four required parameters (env, planId, currency, vendorId) have no description anywhere. The description's phrase 'charges the first cycle' implicitly ties amount to the plan price, but that is already in the schema, so it adds essentially no new parameter meaning to compensate for the documented gaps.

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 ('Create a subscription checkout for a plan') and immediately qualifies it against the one-off sibling: it 'charges the first cycle, stores the card and auto-renews.' That verb-plus-scope framing tells an agent exactly how this differs from create_checkout and create_subscription_plan without opening any 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 closing sentence 'Use after create_subscription_plan' gives an explicit sequencing prerequisite and names the sibling to call first. It stops short of stating when *not* to use this versus create_checkout (e.g., one-off purchases), so the exclusion side of the guidance is left implicit.

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

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

With no annotations, the description does add real behavioral context the schema lacks: the returned planId, the automatic renewal charge to the stored card, and the requirement that the vendor be live. It does not cover idempotency, whether plans can later be edited/deleted, what happens on duplicate names, or auth/error behavior for a mutation 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 compact sentences: what it makes, who it's for, what it returns and how it's used next, then one billing-behavior note. No filler and the key scoping facts are front-loaded.

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

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

For an 8-parameter, 7-required mutation with no annotations and no output schema, the description successfully covers the return value (planId) and the auto-renewal consequence, which an agent cannot infer elsewhere. The remaining gap is lifecycle behavior (editing/deleting plans, duplicate-name errors), which is secondary for a create 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 coverage is 50%; name, price, period, and access_token are documented in the schema, and the "$12/month" example usefully ties price to periodUOM. The description adds nothing for vendorId, env, or currency beyond their enums, and doesn't clarify the period/periodUOM interaction or the uniqueness constraint on name.

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 ("Create a recurring subscription plan") and immediately grounds it with a concrete example ("Pro at $12/month") plus the business use cases it serves. The word "recurring" plus the create_subscription_checkout handoff distinguishes it from the one-time create_checkout 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?

Gives a clear precondition ("for a live vendor", pointing at the go_live sibling) and states the downstream consumer of the returned planId (create_subscription_checkout), which is strong routing guidance. It stops short of explicit exclusions, e.g. when to use create_checkout vs. this tool for one-off charges.

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, and it does substantial work: it discloses that a real merchant account is created, that access tokens are returned, the progressive KYB thresholds (£1,500/£2,500), that individuals go live instantly while companies get an onboarding link, and that sandbox and production are both provisioned by default. It omits reversibility, auth prerequisites, and idempotency, which keeps it short of a 5 for an unannotated mutation 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?

Front-loaded with the core action and immediately followed by the operational mechanics, so an agent gets the gist in the first clause. It is dense but not padded, though the trailing SEO-style keyword list ('Stripe / Stripe Connect / Paddle alternative') is marketing rather than operational information.

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

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

For a 9-parameter, no-annotation, no-output-schema tool, the description covers the important unknowns: what gets created, what comes back (access tokens), the sandbox/production default, and the KYB cap behavior that determines whether the caller needs to handle an onboarding-link flow. Remaining gaps are secondary mechanics like failure modes and what to do with the returned tokens.

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 78%, so the baseline is 3. The description reinforces the two most consequential semantics — company_no presence triggers company vs individual treatment, and env defaults to both environments — but it does not add format or validation guidance beyond what the schema already declares.

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: 'Add payments to an app' and more precisely 'Creates a real merchant/payment account and returns access tokens'. The KYB/provisioning detail makes the operation concrete rather than vague, but it never distinguishes itself from the overlapping sibling add_payments, which sounds like it does something similar.

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?

Lists usage contexts ('accept payments, set up a merchant account, monetize an app') which implies when to reach for it, but gives no when-not conditions and no routing relative to add_payments, identify_business, or create_checkout. An agent with these siblings still has to guess which tool starts the flow.

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 meaningful behavior: inference is done by Opus 4.8 with live web search and website reading, which implies latency, external network access and non-deterministic output. It does not cover failure behavior (what happens when the business can't be identified) or whether results are cached, so it falls short of a 5.

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

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

Two sentences, front-loaded with the purpose and the imperative call ordering, with no filler. The second sentence is a long intent list but each item earns its place as a trigger signal.

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, and the description compensates by naming the returned fields, which is the key information an agent needs to chain into add_payments. The main remaining gap is the not-found / low-confidence case, which is not addressed.

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 parameter already documents itself with examples. The description's "name, website, or short phrase" restates the schema rather than adding format, normalization or ambiguity-resolution guidance beyond it. 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 ("Identify a business") plus the exact return fields: name, description, website, country, region. It is clearly distinguishable from the sibling tools (add_payments, create_checkout) because it is the lookup/enrichment step that precedes 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?

Gives explicit ordering ("Call this FIRST whenever...") and enumerates the triggering intents: accept payments, add a checkout, set up a merchant account, get paid, replace Stripe/Paddle. An agent has a concrete rule for when to reach for this tool versus jumping straight to add_payments or create_checkout.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It only mentions the data returned (status, plan), which is minimal; it fails to disclose crucial operational behaviors like rate limits, required permissions, or potential error states.

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, focused sentence. It uses no superfluous words, and the mention of the optional plan filter adds critical functional information concisely.

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

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

The description provides necessary context by suggesting real-world use cases ('reconciliation or an account page'). However, given the low schema coverage, it is incomplete as it does not explain the format of the expected output or the constraints on the input tokens beyond their existence.

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 very low schema coverage (25%), the description is helpful by clarifying the scope of the optional 'planId,' specifically mentioning the option 'optionally for one plan.' This adds semantic value to an otherwise generic optional string parameter.

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

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

The description clearly states the tool's purpose is to list subscriptions and specifies what data is returned (status, plan). By naming the resource and the action (List), it is easily distinguishable from sibling tools that perform 'create' or 'add' actions.

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 tool provides concrete use cases, such as 'reconciliation or an account page,' which implies usage scenarios. However, it does not explicitly state which alternative tools to use for modifying subscriptions, making the distinction between this tool and the siblings solely dependent on the verb 'List.'

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