MONO eSIM

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

The annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to restate safety basics. It adds useful context by emphasizing that the tool never creates a card setup or charges money, though it could say more about what the returned consent version and conditions contain.

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

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

Two sentences, front-loaded with the core action and sequencing constraint. Every clause adds either purpose, usage context, or a behavioral boundary without unnecessary repetition.

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 tool with no output schema, the description covers purpose, prerequisite timing, and the key non-effect of not moving money. It leaves the return contents slightly implicit, but the essential information needed to select and invoke it correctly 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 tool has zero parameters, so there is no parameter semantics to document. The description appropriately avoids inventing parameter details, matching the baseline for a parameterless operation.

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 (read) and resource (currently required consent version and conditions) and explicitly situates it relative to create_card_authorization. It also clarifies that the tool is for saved-card authorization terms rather than a generic terms lookup.

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 clear timing guidance ('before create_card_authorization') and a use case ('explain future off-session card charges and spending authority'). It does not explicitly compare against the sibling get_terms, which is a reasonable alternative for generic terms.

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 cover read-only/idempotent/non-destructive, and the description goes well beyond them: it discloses the tri-state return (supported=true/false/null), warns that null means unknown rather than incompatible, mentions 'close model matches and caveats', and flags regional-variant and EID/unlock caveats. That is exactly the probabilistic-result context an agent needs before relaying an answer to a user.

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?

Verb and resource are front-loaded in the first clause, followed by return semantics and then the safety advisory in priority order. No filler sentences; each clause adds information the agent will act on.

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 fully documented parameter and no output schema, the description compensates well by explaining the return values and their interpretation. Minor gaps remain, such as data-source freshness and what the 'optional supplier check' entails, but nothing blocks a correct 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 100% and the property description already specifies the full commercial model name and region variant. The description's examples add a little illustrative value but largely restate the same format guidance, 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: 'Look up a phone model's probable eSIM compatibility by model name,' with concrete examples ('iPhone 12 mini', 'Galaxy S21'). It is clearly distinguishable from every sibling (card, wallet, plan and payment tools) without opening the schema.

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

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

Gives clear usage context and boundaries: use it for per-model compatibility lookup, and always advise users to confirm EID and carrier unlock status. It also rules out misuse ('this is not a purchase approval'). It stops short of naming an alternative or an explicit when-not-to-call condition, though no sibling overlaps this function.

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?

Adds real context beyond the readOnly/idempotent annotations: unknown IDs are flagged not_found rather than silently replaced, and the derived fields (cheapest plan, lowest EUR/GB, longest validity) are disclosed. The 'no reservation or purchase' line is slightly redundant with readOnlyHint=true, keeping it just short of 5.

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

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

Three sentences, front-loaded with the verb and input constraint, then the return shape, then the usage boundary. No filler; each sentence carries distinct 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?

No output schema exists, so the description must describe returns — it does, including the summary fields and the not_found behavior. For a 2-parameter read-only tool this is fully sufficient to call it correctly.

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

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

Schema coverage is 100% and the schema already documents the 2–10 range, provenance from search_plans, and not_found handling, so the description mostly restates it. It adds no format or edge-case detail about plan_ids or lang 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+resource ('Compare 2–10 existing eSIM plan IDs') and scopes the input provenance to search_plans or get_plan, which cleanly separates it from both siblings. An agent can identify the 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?

Explicitly says when to use it ('an explicit shortlist') and when not to ('not as the initial destination search'), naming the upstream alternatives. The 'makes no reservation or purchase' clause further excludes it from the purchase path.

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 non-destructive, idempotent, open-world behavior, but the description adds real value beyond them: 'this call stores consent and limits but does not charge the card' and 'reuse idempotency_key on retries.' It does not cover what happens to prior consent or SetupIntent expiry, which keeps it from a 5.

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

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

Three tight sentences, front-loaded with the core action, then the required call sequence, then the safety constraints. 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 consent-storing mutation with no output schema, the description covers prerequisites, the handoff sequence, the no-charge guarantee, and hints at a returned client_secret. The main residual gap is the undisclosed meaning of the four required parameters.

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 0% across six parameters, so the description must carry the burden. It only explains idempotency_key usage and alludes vaguely to 'limits'; it says nothing about payment_authorized, consent_version, valid_days, or the per-purchase/day cent ceilings.

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 Stripe SetupIntent) scoped to 'this authenticated machine' and gated on saved-card consent. It is clearly distinguishable from siblings like sync_card_authorization and card_payment_terms, which are named in the workflow.

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 and alternatives: 'Call card_payment_terms first, then complete the returned client_secret with Stripe.js and call sync_card_authorization.' It also states a hard exclusion ('never send PAN/CVC to this tool'), so the agent knows both when and how not to use it.

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 cover the safety profile (readOnly=false, idempotent=true, openWorld=true), and the description adds value beyond them: it clarifies the return is a checkout URL not a paid eSIM, that fulfilment only begins after verified payment, and that idempotency keys must be reused across retries to avoid duplicate orders. This is exactly the kind of consequence-level context annotations cannot express.

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 action and the source of quote_id, with preconditions and caveats following in a logical order. It is dense (roughly three long clauses) but no sentence is filler; minor tightening would make it a 5.

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

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

For a mutation tool with no output schema, the description supplies the missing return-value information (checkout URL, pending state), the fulfilment timing, and the retry/idempotency policy. An agent has everything needed to decide when to call it and how to handle repeats.

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 baseline is 3; the description nonetheless adds intent-level meaning by framing customer_confirmed and terms_accepted as explicit customer-approval gates rather than mere booleans, and explains the idempotency_key reuse rule beyond the schema's 'unique per purchase'. Email and lang semantics are left entirely to 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 and resource ('Create a pending customer-paid Stripe Checkout') plus the exact input provenance ('from a quote_id returned by prepare_order'). It explicitly distinguishes the result from a completed purchase ('returns a checkout URL, NOT a paid eSIM') and names the sibling to use for other payment methods.

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 preconditions for invocation (only after the customer approved the displayed plan and price and accepted terms) and routes to the alternative ('use purchase for other supported payment methods'). Retry behavior is also covered via idempotency_key reuse.

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?

Beyond the annotations, the description discloses critical behavior: the balance changes only after verified test payment, not after opening the checkout link, and that idempotency_key should be reused for retries. It also clarifies this is test-only and no real money is accepted, which is exactly the context an agent needs for a mutation/write operation.

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

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

The description is two dense sentences with no wasted text. It front-loads the purpose and then immediately adds the key behavioral caveats about payment verification and retries.

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-parameter funding tool with no output schema, the description covers the purpose, amount units, idempotency behavior, and payment verification caveat. It does not describe what the returned checkout session contains or any endpoint/auth prerequisites beyond the authenticated machine context, but an agent can invoke it correctly.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains amount_cents is integer EUR cents with 100 = EUR 1.00, and it explains idempotency_key should be reused for retries. The idempotency_key format or max length is not described, but the core semantics are covered.

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: create or retrieve an offline-sandbox Stripe TEST Checkout session for funding this machine's test wallet. It clearly distinguishes the operation from sibling tools like get_wallet or create_checkout by naming the exact session type and test-wallet funding scope.

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 clearly establishes when to use it: to fund the authenticated machine's test wallet via a test Checkout session. It also explains retry behavior with idempotency_key and that no real money is accepted, though it does not explicitly name alternatives or when not to use this tool.

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 read-only, idempotent, non-destructive, closed-world, but the description adds real context: the response may contain activation codes, LPA, QR/install links and usage data, and that token/activation data are secrets not to be shared publicly. It also clarifies the semantic limit that the call does not itself confirm payment.

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

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

Three front-loaded sentences with the core action first and the secrecy caveat last. Minor redundancy between "treat the token and activation information as secrets" and "do not share the output publicly," which say nearly the same thing.

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

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

With no output schema, the description does the work of sketching the return payload (status, activation code, QR/install links, usage data) and flags the sensitivity of the result. It omits error behavior for an invalid or mismatched token and does not explain how include_usage changes the response.

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 0%, so the description must carry the load. It explains order_id/order_token provenance and secrecy, but the third parameter include_usage is never mentioned, leaving an agent to guess whether usage data appears only when set.

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

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

States a specific verb and resource ("Retrieve payment/fulfilment status") scoped to "exactly one order" and names the two identifiers required. This clearly separates it from sibling mutations like prepare_order, purchase, and create_checkout.

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?

Establishes the precondition that order_id and order_token come "from checkout or purchase," which tells the agent this is a post-purchase lookup. It also warns the result "never confirms payment by itself," but never explicitly contrasts with siblings such as prepare_order or get_wallet.

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, idempotentHint, closed-world and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the not_found outcome for missing or withdrawn plans and the fact that stale cached prices should not be trusted. It stops short of describing auth needs or rate limits, so 4 rather than 5.

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

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

Three sentences, each load-bearing: verb+resource+returned fields first, usage/next-step second, error handling last. No filler, and the identification ('Retrieve one current eSIM plan by plan_id') is 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 compensates by enumerating the returned fields (EUR price, coverage destination, data allowance, validity, availability, purchase terms). With 3 params, full schema coverage, and clear error semantics, nothing an agent needs to invoke it correctly is missing.

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 baseline is 3. The description earns above that by clarifying that destination must be an exact slug rather than a free-text city and that plan_id comes from search_plans and is not a name, adding disambiguation the schema only partially conveys.

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

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

States a specific verb and resource ('Retrieve one current eSIM plan by plan_id') and immediately scopes it against siblings by naming search_plans as the source of the ID and prepare_order as the downstream step. An agent can tell this apart from search_plans and compare_plans 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?

Explicitly prescribes when to call it ('confirm an offer before prepare_order') and what to do on failure ('A missing or withdrawn plan returns not_found; search_plans again instead of relying on cached prices'), which also warns against a wrong alternative behavior. Alternatives and their triggering conditions are named rather than 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?

Beyond the read-only annotation, the description clarifies that this neither records agreement nor grants payment authorization. That is a meaningful behavioral distinction for an agent to understand before showing terms.

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

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

The description is front-loaded with the retrieval purpose, followed by timing guidance and a crucial non-effect clarification. Every sentence contributes useful information with no waste.

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

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

For a simple one-parameter read tool with rich annotations and no output schema, the description covers what is returned, when to use it, and what it does not do. Nothing essential is missing.

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%, including the lang enum and default. The description restates the language options, which is useful context but adds no syntax or 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?

The description states a specific verb and resource: retrieve eSIM purchase terms and legal links. It is clear what the tool returns, but it does not explicitly differentiate itself from the sibling card_payment_terms tool.

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

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

The description gives clear timing guidance: show these to the customer before confirmation and checkout. It does not explicitly name alternatives or when not to use it, but the context is strong enough for correct invocation.

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 readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: a hard 100-entry cap per call, the units (EUR cents), the 'own machine only' scope, and the pagination trigger, though it says little about the shape of the returned balance/limits object.

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

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

Three sentences, each carrying distinct information: what is returned, the pagination mechanics, and the sibling routing. The key scope and cap are front-loaded with no filler.

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

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

For a zero-required-param read with full schema coverage and annotations covering safety, the description supplies everything an agent needs: scope, units, cap, pagination procedure, and the alternatives for the two mutating operations.

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 offset parameter is documented in the schema, so baseline would be 3. The description earns an extra point by supplying concrete paging mechanics (offset=100, 200, ...) and tying offset to next_offset, which the schema only gestures at.

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 (read) plus concrete resources (EUR-cent balance, spending limits, latest ledger entries) scoped to the authenticated sandbox machine's own wallet. It is immediately distinguishable from the two wallet-related siblings it names.

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?

Explicitly routes the agent: fund_wallet for creating a test funding checkout, set_wallet_limits for changing limits, and states this tool does neither. It also gives the condition for paginating (when next_offset is present).

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 readOnly, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description adds genuinely new context: results are informational only and do not reserve inventory or prices, which prevents an agent from treating output as a booking or price lock.

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 tight sentences: purpose and payload first, routing guidance second, behavioral caveat last. No redundant restatement of the title or schema.

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

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

No output schema, yet the description tells the agent what fields come back (names, identifiers, starting EUR prices) and what the results do not imply (no reservation). Combined with full annotation coverage, nothing needed to call this correctly is missing.

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 baseline is 3, but the description adds real semantics for `type` — that country and region are the two options and omitting it returns both — which the schema's bare 'Filter by type.' does not convey. `lang` is left to the schema, which fully documents it.

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 plus resource ('List currently offered travel eSIM destinations') with scope detail: countries and multi-country regions, localized names, identifiers, starting EUR prices. It is clearly distinguishable from search_plans, which the description names as the downstream step.

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?

Explicitly states when to use it ('when the travel destination is unknown or to discover valid destinations before search_plans') and how to apply the type filter ('type=country or type=region, or omit it for both'). The alternative tool and the condition that selects it are both named.

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 cover safety (readOnly, idempotent, non-destructive, closed-world), yet the description still adds non-obvious semantics: enabled vs planned is not a chargeability signal, and silent fallback to Stripe Checkout is prohibited. That is real behavioral context beyond the structured fields.

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

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

Three sentences, all load-bearing, with the operational imperative front-loaded before the field inventory and the caveats. No restatement of the title or name.

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, so the description carries the return-shape burden — and it does: it enumerates status, environment (live/sandbox/offline_sandbox), required customer interaction, supported buyer modes, and unavailable reason. Nothing essential for correct invocation is missing.

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?

Zero parameters, so there is nothing for the description to disambiguate and the baseline applies. It correctly omits parameter talk rather than padding, though it also doesn't state that no inputs are needed (e.g., environment scoping comes from the caller's context).

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 ('Read the payment-method capability matrix') and explicitly separates itself from the write-path sibling by naming purchase and create_checkout-adjacent behavior. An agent can distinguish discovery from action without opening a schema.

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

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

Gives explicit ordering guidance ('BEFORE invoking purchase'), plus when-not reasoning: a planned method may not charge, and autonomous flows must not silently fall back to human Stripe Checkout. This is exactly the when/when-not/alternative coverage the dimension asks for.

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?

Goes beyond the annotations by disclosing the 30-minute price lock, the exact outputs (quote_id, current price, customer-confirmation requirements), and the absence of side effects. The readOnlyHint/idempotentHint annotations already cover the safety profile, and the description reinforces rather than contradicts them; it could still say what happens when the quote expires.

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 action and artifact, followed by outputs, the 30-minute lock, the no-side-effect guarantee, and next steps. No filler.

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

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

With no output schema, the description usefully enumerates the return values and the follow-on tools, and it clarifies the non-mutating nature of the call. The only real gap is the undocumented destination parameter.

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 33%: lang is documented in the schema, but plan_id and destination have no schema descriptions. The description compensates for plan_id by naming the tools that produce it, yet destination is left entirely unexplained in both places.

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 artifact: 'Prepare a time-limited signed quote' for a plan_id. It also ties the resource to how it's obtained (search_plans or get_plan), which cleanly separates it from purchase, create_checkout, and get_order.

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?

Explicitly names the prerequisite lookup tools and the two downstream alternatives, with the condition selecting each ('create_checkout for customer-paid Stripe Checkout or purchase for an enabled alternate method'). It also states the negative case: no order, payment, or eSIM is created.

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 openWorldHint, idempotentHint and non-destructive, but the description adds real side-effect context: an order may be created or a payment started, authority/balance must exist, and success must not be assumed before verified payment. It does not say what state the order lands in if payment fails or is abandoned, which is the main remaining behavioral gap for a payment 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 sentences, front-loaded with the action and the quote source, then preconditions, then the retry/success caveat; nothing is redundant. The middle sentence is a long run-on stacking several conditionals, which slightly hurts scannability but not content density.

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-output-schema payment tool this covers the critical decision points: mode selection, capability gating, confirmation requirements, idempotency and verification. It is incomplete on half the payment_method enum (x402, mpp, b2b_credit) and on failure/pending return behavior, which the absent output schema would otherwise have to answer.

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 22%, so the description carries most of the load and does well: it ties quote_id to prepare_order, payment_method to payment_capabilities, and explains that email, terms_accepted and customer confirmation are conditional on stripe_checkout plus the idempotency_key contract. It leaves the buyer_mode values and the x402/mpp/b2b_credit methods unexplained, so three of nine parameters are unglossed.

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 ('Attempt a purchase for a quote_id') and anchors it to the producing sibling 'prepare_order'. The final clause clarifies the outcome ambiguity ('can create an order or start a payment'), which is exactly the distinction an agent needs versus create_checkout or create_card_authorization.

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 concrete preconditions per path: buyer_mode and payment_method must be explicitly selected and validated against payment_capabilities, stripe_checkout needs human/delegated confirmation, accepted terms, customer email and a customer-paid link, while agent_wallet/stripe_off_session require enabled offline-sandbox capabilities. It never states when to prefer this tool over create_checkout, so it stops short of explicit alternative 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 the safety profile (readOnly=false, destructive=false, idempotent=false, openWorld=true), and the description adds genuinely new behavior: the API key is returned once and 'cannot be retrieved again', no email or human account is needed, and the wallet starts at zero EUR. The one-time-secret warning in particular prevents an unrecoverable agent mistake.

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, front-loaded with the action and its outcome, then the sequencing, then the one-time key warning and the exclusion. No filler; each clause carries distinct 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, but the description still discloses the salient return value (the `mak_test_` key) and its irreversibility, along with the wallet starting balance. For a one-parameter creation tool, nothing an agent needs to call it safely is missing.

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 'name' parameter is fully documented in-schema as a non-secret audit label. The description adds no further meaning about the parameter (e.g., its effect on the returned identity), 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 NEW offline-sandbox machine identity') plus its immediate consequences (zero-EUR test wallet, one-time API key). The closing clause 'This does not create a live payment account' explicitly separates it from the live-payment siblings, so an agent can distinguish it 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 an explicit prerequisite ordering — use before get_wallet, fund_wallet, set_wallet_limits, or sandbox purchases — which is exactly the routing an agent needs among these siblings. The negative case ('does not create a live payment account') is stated, though it doesn't name which sibling to use instead for live accounts.

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?

Beyond the destructive annotation, the description explains that new purchases are blocked while reserved or in-flight payments may still settle and require reconciliation. It also clarifies non-effects: no Stripe customer deletion and no prior-charge refunds, which is valuable behavioral context for this 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?

Three sentences, each doing useful work: the action, the settlement caveat, and the explicit non-effects. It is front-loaded and free of repetition.

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 destructive mutation with no output schema, the description covers purpose, side effects, and non-effects well. The remaining gap is the lack of authorization_id semantics, but the overall context is sufficient to invoke it correctly.

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

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

The only parameter, authorization_id, is named but not explained beyond its schema name. With 0% schema description coverage, the description should define the identifier's source or format, but it only states that revocation is performed by authorization_id.

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

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

The description uses a specific verb, "Revoke," names the exact resource, "saved-card spending permission," and scopes it to the authenticated machine's own authorization_id. This clearly distinguishes it from sibling tools like create_card_authorization and sync_card_authorization.

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 revocation action, but the description does not explicitly compare this tool with alternatives such as sync_card_authorization or state when not to use it. The caveats clarify consequences rather than 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is covered; the description adds substantial value by clarifying what survives (transaction and ledger history) and what is explicitly NOT done (no cash out, refund, or fund transfer). It does not explain behavior on a repeat call against an already-revoked key, even though idempotentHint=false flags that as a meaningful case.

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

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

Three sentences, front-loaded with the irreversible effect, then the preserved state, then the usage boundary. Every sentence carries distinct decision-relevant information with no repetition of the title or annotations.

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, no-output-schema mutation tool with full annotation coverage, the description says everything an agent needs: what is disabled, what remains, what is not performed, and when to choose it. Nothing material is missing.

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 no parameter semantics to convey and the baseline is 4. The description correctly scopes the action to the authenticated machine rather than implying any selector argument exists.

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: permanently disable the authenticated sandbox machine's current API key, and states the downstream effect (wallet and purchase requests with that key are blocked). This clearly separates it from siblings like register_machine, set_wallet_limits, or revoke_card_authorization.

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 both a when ('decommissioning or securing the machine') and an explicit when-not ('not when merely changing spending limits'), which also implicitly routes the agent to set_wallet_limits for the adjacent case. No inference required.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description adds context beyond them: no stock is reserved, and the response includes a cheapest-match recommendation alongside price/validity details. That pre-empts an agent worrying that searching has side effects or requires a follow-up to compare prices.

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-loads purpose, then filters, then return shape, then routing alternatives — a logical order with no filler. The first sentence is long and list-heavy, but every clause is load-bearing; no sentence 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?

With 8 parameters, no output schema and 75% schema coverage, the description usefully summarizes the return payload (matching plans, price/validity details, cheapest-match recommendation) and the full call sequence around it. The only gap is that 'limit' behavior (pagination/cap of 50) and any default page size go unmentioned.

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 description adds genuine semantics the schema alone leaves ambiguous — 'days' is explicitly a minimum (trip length) and 'data_gb' a minimum, not exact — and maps unlimited and max_price_eur to filter intent. It does not mention the 'limit' or 'lang' parameters, which are the two with the least schema documentation.

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?

Opens with a specific verb+resource ('Find available travel data eSIM plans') and enumerates the destination granularity with concrete examples ('Japan', 'Tokyo', 'Europe', 'TR'). An agent can immediately distinguish this lookup/search tool from siblings like compare_plans and get_plan.

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?

Explicitly routes the agent: use get_plan to validate a chosen plan, then prepare_order; use list_destinations when a location is not recognized. It also states the key negative — 'without reserving stock' — so the agent knows this is a safe exploratory step before the purchase 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?

Adds behavior beyond the annotations: zero blocks future spending, and refunds do not restore the already-consumed daily limit — a genuinely non-obvious semantic. It also clarifies the authorization boundary. It does not, however, state that existing limits are overwritten by the call, despite destructiveHint=false and idempotentHint=false leaving that ambiguous.

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 dense sentences with the resource, unit, and zero-state semantics front-loaded; the prerequisite and non-scope caveats follow. No filler or restatement of the title.

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-parameter mutation with no output schema, the description covers units, effects, preconditions, and exclusions. It omits what the call returns and whether both limits are applied atomically, which an agent might want before relying on the result.

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

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

Schema description coverage is 0%, so the description carries the burden — and it does map both parameters to their meaning (per purchase and per UTC day, in integer EUR cents). The 1,000,000 upper bound and 0 minimum remain schema-only, and there's no guidance on interaction between the two values.

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 (change spending limits) scoped to 'this authenticated sandbox machine', and specifies the unit of measure (integer EUR cents per purchase and per UTC day). An agent can immediately tell this apart from sibling read tools like get_wallet or payment-flow tools like purchase/create_card_authorization.

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?

Explicitly directs the agent to call get_wallet first to inspect current limits, giving a clear call ordering. It also delimits scope ('does not authorize another person's card or make a purchase'), though it does not contrast against other mutation siblings such as fund_wallet or revoke_card_authorization.

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?

Adds real context beyond annotations: the call may activate the permission only after successful setup and ownership checks, and never charges a card — resolving the main ambiguity of a mutating call in a payments system. However, annotations declare idempotentHint=false and the description says nothing about retry safety or what happens if the ownership check fails, which is the key remaining behavioral gap for a non-idempotent 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?

Three tight sentences ordered trigger → mechanism → exclusions, with zero restatement of the name or title. Every sentence carries routing or safety 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 one-parameter mutation with no output schema, the description covers trigger, prerequisite, effect (permission activation only, no charge), and alternatives. It stops short of describing failure behavior or the safe retry path implied by non-idempotency, which would fully close the loop.

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 pointing at create_card_authorization, so the schema does the heavy lifting. The description restates the same provenance hint plus a 'for this machine' scoping note, adding marginal value rather than new syntax or format detail.

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

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

Specific verb ('reconcile') plus resource ('saved-card authorization with Stripe') plus the precise trigger ('after completing a Stripe SetupIntent with Stripe.js'). It explicitly names the two siblings it is not (create_card_authorization, sync_card_payment), so an agent can route correctly 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 the precondition (SetupIntent completed via Stripe.js), the required input provenance (authorization_id from create_card_authorization), and two explicit exclusions with the alternative tool named for each. No inference is required to choose between this and its siblings.

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?

Discloses real behavioral traits beyond the annotations: the possible outcomes (resume a pending charge, complete verified fulfilment, or return a 3DS/Stripe.js action requirement), the ownership check against Stripe, and the anti-retry safety rule. One ambiguity: it calls the pending charge 'idempotent' while annotations declare idempotentHint=false, which could mislead an agent into blind retries, though the phrase describes the charge rather than the call.

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 verb and scope, then outcomes, then the negative constraint and the alternative. Three dense sentences with no filler or repeated annotation content.

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 a single parameter, the description carries the burden well by enumerating the three possible terminal states and warning against retry. Minor gaps remain around what the agent should do with a returned 3DS action and any machine-registration/auth prerequisites, but nothing critical for correct invocation is missing.

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 sole parameter already documents its own provenance in nearly identical wording, so the description adds little beyond the schema. The added value is only the reminder that the ID must come from a stripe_off_session purchase specifically, which is baseline-adequate for a one-param 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?

States a specific verb ('Reconcile') and resource ('saved-card purchase') and pins the input's provenance to a sibling tool ('order_id returned from purchase with payment_method=stripe_off_session'). It also distinguishes itself from get_order and from sync_card_authorization by describing what it does that they don't (PaymentIntent ownership/status check).

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 preconditions (an order_id from a stripe_off_session purchase), explicit prohibitions ('Do not retry with a new order or bypass bank authentication'), and names the alternative for a different need ('use get_order to read ordinary delivery status'). The when/when-not routing is fully specified.

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