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

With no annotations, the description does carry the important disclosure that this mutates state ('Changes account state') and that confirm=true is required, which is real behavioral value. It does not say whether activation is reversible, what permissions or prerequisites apply, or what effect activation has on the bon beyond state change.

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

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

Two compact sentences with zero waste: the action first, then the state-change warning and the confirm requirement. Nothing is repeated from the schema or padded.

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 tool with an output schema available, the essentials are present: what it does, that it mutates account state, and the confirm gate. Remaining gaps (reversibility, permissions) are secondary given the small surface area.

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 compensate. It successfully explains the meaning of confirm (a required safety acknowledgement, despite the schema defaulting it to false), but adds nothing about bon_id's format or provenance beyond its 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?

The description gives a specific verb and resource ('Activate a Cumulus bon'), which is immediately distinguishable from mutating siblings like redeem_cumulus_bon or deactivate_coupon by the word 'activate'. It stops short of explicitly naming the closest sibling (redeem_cumulus_bon), so full differentiation is left to inference.

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 states a hard precondition ('needs confirm=true') but gives no guidance on when to choose this over redeem_cumulus_bon or when not to activate a bon at all. Usage is implied by the verb rather than explained.

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 must carry the behavioral load: it does disclose that this mutates account state and requires an explicit confirm flag, which is the most important thing an agent needs. It omits reversibility, permission/auth requirements, failure modes, and what happens if confirm is left at its default false.

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

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

Two short clauses, no filler, and the mutation warning and confirm requirement are front-loaded where an agent will see them before calling. 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?

An output schema exists, so the description is not obliged to explain return values, and for a two-parameter mutation the key facts (state change, confirm gate, EAN key) are present. Preconditions and irreversibility of the activation would be the remaining gaps for a state-changing tool with no annotations.

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 has to supply the meaning, and it covers both parameters: ean is the lookup identifier for the coupon, and confirm is a required safety gate that must be true. What is missing is format expectations for ean (length, digits) and the explicit consequence of confirm being false rather than absent.

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?

"Activate a Cumulus coupon by EAN" gives a specific verb, resource and lookup key, which clearly separates it from deactivate_coupon and the read-only cumulus_coupon/cumulus_coupons siblings. It does not explicitly name those alternatives, so it stops just short of full sibling differentiation.

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

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

The description implies the use case (activating a coupon you hold) and states the confirm=true prerequisite, which is real guidance. It never says when to prefer this over cumulus_coupon (inspect first) or deactivate_coupon, and gives no preconditions such as whether the coupon must be unexpired or already in the 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that this mutates account state and requires confirm=true despite the schema default of false, but it omits reversibility, idempotency, auth requirements, and behavior when the product is already a favourite.

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

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

Two short, front-loaded sentences with no filler. The key precondition is included efficiently.

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-parameter mutation with an output schema, the description covers the action, state change, and confirm requirement. It leaves product_id semantics and some mutation edge cases implicit, but remains largely sufficient for invocation.

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 compensate. It clarifies that confirm must be true, but it does not explain product_id semantics, format, or where the identifier comes from.

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: 'Add a product to favourites.' The action is clear, but it does not explicitly distinguish this from sibling tools such as remove_favourite or is_favourite.

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 important precondition: confirm=true, and notes the account state change. However, it does not explain when to use this versus checking is_favourite first or using remove_favourite for the opposite action.

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

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

With no annotations, the description carries the full burden. It usefully discloses the confirmation gate ('Needs confirm=true'), which is real behavioral context absent from the schema, but it does not say whether the operation appends to or replaces the existing list, how duplicate products are handled, or whether it is idempotent.

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

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

Two short sentences with zero filler, and the core action is front-loaded ahead of the precondition.

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 tool with an output schema, the definition covers the action and the critical confirmation requirement. The remaining gaps around list-merge semantics are noticeable but modest given the tool's simplicity.

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 compensate. It explains the confirm flag's required value, adding genuine meaning beyond the bare boolean, but says nothing about order_id's format or valid sources beyond the vague 'past order'.

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: 'Add every product of a past order to your shopping list.' The phrase 'every product of a past order' implicitly separates it from the single-item sibling add_shopping_list_item, though no sibling is named explicitly.

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

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

Usage is implied (re-adding the contents of a previous order) and the confirm=true precondition is stated, but there is no explicit when-not guidance, no mention of prerequisites such as the order needing to be completed, and no named alternative for adding single items.

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 supplied, so the description carries the full behavioral burden and largely fails it. It never states whether this is a read-only search, whether authentication is required, whether the limit parameter truncates results, or how ambiguous or partial matches are handled — only the barest hint of a read-only lookup is conveyed by the word "lookup".

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 filler, and the primary required input is named first. It is efficient but borders on under-specification rather than being optimally sized for a five-parameter tool.

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

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

An output schema exists, so return values need not be described. Still, for a five-parameter tool with no annotations and no schema descriptions, the one-line description leaves too much unspecified — notably the city vs. zip_or_city relationship and the limit semantics.

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 compensate. It explains zip_or_city (postcode/town) and the optional street and house number, but leaves city and limit entirely unaddressed — and city is especially problematic because its relationship to the required zip_or_city field is left ambiguous.

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

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

The description gives a specific verb/resource ("Swiss address lookup") plus the key inputs (postcode/town, optional street and house number), which is far more informative than the bare name. It does not, however, distinguish this from nearby siblings like my_addresses, my_address, or find_stores, which a caller could plausibly 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?

Usage is only implied: an agent can infer this is for resolving/validating Swiss addresses from a postcode or town. There is no explicit statement of when to prefer this over my_addresses (saved addresses) or find_stores, and no preconditions or exclusions are given.

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

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

With no annotations, the description does carry real weight: it discloses that this is a mutating 'Firestore write' and that confirm=true is required, the latter resolving an ambiguity the schema leaves open (confirm is optional with default false). However, it says nothing about permissions, duplicate handling, side effects on the list, or whether the write 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?

Two short sentences, front-loaded with the action and followed by the key constraint, with no filler. It is arguably too terse, but nothing present is wasted.

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

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

For a 5-parameter mutation with zero annotation coverage, the definition is thin: four parameters are unexplained and no preconditions about the target list are given. An output schema exists, so return values need not be described, but the input-side gaps remain significant.

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 5 parameters. The description only addresses 'confirm'; it adds no meaning for list_id, name, note, or quantity, nor does it explain what confirm actually gates. Given the low coverage, the description should compensate and largely does not.

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 ('Add an item to a shopping list'), which is clearly distinguishable from siblings like complete_shopping_list_item and remove_shopping_list_item. It does not explicitly name those siblings, so it falls short of a 5.

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

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

The only usage guidance is the requirement 'Needs confirm=true', which is useful but is a call precondition rather than a when-to-use-vs-alternatives statement. There is no indication of when an agent should add an item versus completing, removing, or listing items.

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. It says it creates a pass and requires confirm=true, but does not disclose authorization needs, whether an existing pass is replaced, what happens if confirm is false or omitted, or any rate limits. The output schema may cover return values, but the mutation behavior remains largely undisclosed.

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 short sentences, front-loads the action and resource, and includes the required confirm behavior without any filler. Every sentence earns its place.

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

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

For a simple one-parameter pass-creation tool with an output schema, the description gives the core action and confirm requirement. It still omits important context such as authentication, replacement behavior, and the effect of non-confirmation, leaving gaps for an agent invoking a mutation.

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% for the single confirm parameter, so the description must compensate. It does state that confirm=true is needed, which adds the crucial requiredness meaning beyond the schema's default false, but it does not explain the consequence of false or omitted confirm.

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: creating an Apple Wallet pass (.pkpass) for the Cumulus card. It is distinguishable from the google_wallet_pass sibling by platform, though it does not explicitly name or compare against that 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?

The description implies usage for generating an Apple Wallet pass, and the note 'Needs confirm=true' gives a prerequisite. However, it does not explain when to use this versus cumulus_wallet or google_wallet_pass, nor does it state any exclusions or conditions beyond the confirm flag.

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 supplied, so the description carries the behavioral disclosure burden. It usefully reveals that the operation mutates checkout and requires `confirm=true`, but it omits what `confirm=false` does, whether the mutation is reversible, what happens with invalid or expired codes, and whether any authentication or basket state is required.

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 definition is compact and front-loads the primary action before the checkout-mutation warning. There is no filler, though the second clause is terse enough to be somewhat cryptic about confirmation semantics.

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 checkout-mutating tool with no annotations and 0% schema description coverage, the description is thin. The output schema covers return values, but the definition still lacks confirmation behavior, failure handling, and sibling-tool guidance that an agent needs before invoking it.

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 explain the two parameters. It only clarifies `confirm=true`, and even that is stated as a requirement rather than explaining the boolean's false/default behavior; it says nothing about the `code` parameter's format, case sensitivity, or validity constraints.

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 and resource: 'Apply a voucher/promo code to the current basket.' It clearly distinguishes voucher application from the many coupon-management siblings, though it does not explicitly name the closest alternative such as `activate_coupon`.

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 implied usage context by saying the tool applies a code to 'the current basket' and that it changes checkout. However, it does not state when to prefer this over `activate_coupon`, `cumulus_coupons`, or `redeem_cumulus_bon`, nor does it describe failure conditions or prerequisites.

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

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

With no annotations, the description must disclose behavior; it identifies a payment-authorization mutation and a mandatory confirmation gate, which is more than nothing. It does not explain side effects, reversibility, permissions, or what happens if the order is already authorized, so key behavioral risks remain undisclosed.

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

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

Two short sentences, front-loading the action and then the key confirmation requirement, with no redundant wording. The terseness does not itself create clutter; missing details are a completeness issue rather than a conciseness problem.

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 a financial mutation with a nested, undocumented payload and no annotations, so it needs substantial contextual explanation. The description supplies only the action and confirm=true, leaving payload shape and operational consequences unclear, even though the output schema covers return values.

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%, and the description only documents the confirm flag's required value. The required payload object—including what fields it should contain—is left entirely unexplained, so the description does not compensate for the schema's lack of parameter 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?

The description names a specific verb ('Authorise') and object ('an order's payment'), so the tool's purpose is unambiguous. It does not explicitly differentiate from siblings such as order_authorization_state, cancel_order, or place_order, so it stops short of a 5.

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

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

It states a prerequisite for calling the tool ('Requires confirm=true'), which tells the agent a condition for a successful invocation. However, it gives no guidance on when to choose authorization over alternatives like place_order or order_authorization_state, nor any exclusions.

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 supplied, so the description carries the full behavioral burden. It only restates the three kinds of results and says nothing about minimum term length, prefix vs. substring matching, localization, or whether results are cached or ranked — the details an agent needs to call an autocomplete correctly.

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

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

A single front-loaded sentence with the key qualifier ('search-as-you-type') first and the result types following. No padding, though the colon-fragment style leaves the subject implicit.

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?

An output schema exists, so the description needn't explain return values, and tool complexity is low. Still, the one input parameter is undocumented everywhere and the sibling routing to search_products is left to inference, leaving a gap for an agent choosing between them.

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 one required parameter with 0% schema description coverage, and the description adds no meaning for 'term' — no indication of whether it is a prefix, partial word, or full query, nor any length or format constraints. With a real coverage gap, the description should compensate and does not.

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 the resource concretely (suggested terms, matching categories, top products) and frames it as search-as-you-type, which separates it from a full product search. It is clear what the tool returns, though it never uses a verb like 'returns' or 'suggests' explicitly.

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

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

'Search-as-you-type' implies the trigger condition (call while a user is still typing), but the description never states when not to use it or that search_products/search_products_guest is the alternative for actual result pages. Usage is inferable rather than stated.

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

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

No annotations are supplied, so the description carries the full burden, yet it says nothing about whether this is a read-only operation, what happens with an unknown slug, auth requirements, or caching. The presence of an output schema relieves it of describing return values, but that is the only gap it does not need to fill.

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, front-loaded with the resource and key, and the three examples each earn their place by pinning down slug format. Slightly fragmentary grammar, but nothing is wasted.

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

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

For a one-parameter read tool with an output schema, the definition covers the essentials: what it returns (a brand page) and what the key looks like. The main omission is its relationship to brand_products, which matters given how many sibling tools share this namespace.

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% and the single 'slug' property is undocumented in the schema, so the description's examples ('m-budget', 'migros-bio', 'v-love') do real work by showing the lowercase-hyphenated identifier format. It still omits case sensitivity and where an agent should obtain a valid slug.

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 a specific resource ('Brand page') and a lookup key ('by slug'), and the examples make the domain concrete. But the verb is implicit (fetch/retrieve) and it does not distinguish this from the obvious sibling brand_products, which an agent could easily confuse with it.

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 at all: no mention of when to prefer this over brand_products, product_detail, or search_products, and no stated preconditions. The agent must infer usage purely 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, yet it discloses only that results are "priced and paginated" — it says nothing about auth requirements, default/max page sizes, ordering semantics, or whether an unknown brand slug errors or returns an empty list. "/paginated" hints at limit/offset but leaves the pagination contract opaque.

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?

Seven words with no filler and the scope front-loaded, so it is efficient, but it is under-specified rather than concise: a single fragment cannot carry the omissive parameter and behavioral detail an agent needs. Structure is acceptable; content density is too low.

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?

An output schema exists, so return values need not be explained, but for a 5-parameter, zero-coverage, zero-annotation tool the description leaves too much to inference — slug format, sort/direction semantics, and pagination bounds are all missing. Comparable siblings like category_products and label_products receive the same treatment, which suggests a family-wide gap rather than a deliberate minimalism.

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 5 parameters, including the required `slug` whose format (brand slug vs. numeric id) is never stated. The description's "priced and paginated" loosely gestures at limit/offset, but says nothing about `sort`, `direction` (asc default, which field it applies to), or the default limit of 12.

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?

"Products of a brand" names a specific resource with a clear scope (brand), which an agent can distinguish from the generic search_products or category_products siblings. It is a noun fragment rather than a verb+resource statement, and it never explicitly names the alternatives it differs from.

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 and no reference to alternatives such as search_products, category_products, label_products, or brand_detail, all of which plausibly overlap. The only implied usage signal is the word "brand", which the agent must infer means a brand slug input.

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 supplied, so the description carries the full behavioral burden. It does creditably disclose that the operation is destructive and gated behind confirm=true, which is exactly the safety context an agent needs, but it omits permissions, whether the cancel is reversible, and the effect on payment/refund — meaningful gaps for a destructive action.

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 clauses, zero filler, and the destructive warning is front-loaded right after the action statement. Nothing here could be cut without losing 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?

This is a simple two-parameter tool with an output schema, so return values need not be described. The description covers the action, its destructive nature, and the confirmation gate — the core requirements. Only preconditions such as which order states permit cancellation are missing, a minor gap at this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It does so for the non-obvious parameter by stating confirm=true is required for this destructive call (the schema only lists it as a boolean defaulting to false), and order_id is self-evident from the verb. Two parameters at low coverage with the risky one explained supports a 4.

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

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

The description opens with a specific verb+resource ('Cancel an order'), making the effect immediately clear and separable from sibling order tools such as order_detail, my_orders, or place_order. It stops short of naming those siblings or the order states where cancellation applies, which keeps it from 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?

It gives one concrete precondition (confirm=true), which is genuinely actionable usage guidance. However, it says nothing about when cancellation is allowed versus other order actions, nor what to do when cancellation is not possible, leaving alternatives and exclusions 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?

With no annotations supplied, the description carries the full disclosure burden, yet it says nothing about read-only behavior, what happens when a slug is unknown, or whether the path must be a complete taxonomy path. The presence of an output schema removes the need to document return values, but the missing operational context is still a real 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?

The text is short and the example earns its place, but it is a sentence fragment with no lead-in verb, leaving the reader to infer what is being described. Brevity here reflects under-specification rather than discipline.

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

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

For a single-parameter lookup tool with an output schema, the bar is low, but the definition still omits what the tool resolves, when it is the correct choice, and how invalid slugs behave. An agent could infer the call signature from the schema but not the tool's role in the taxonomy workflow.

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 compensate, and it partially does by supplying a concrete example slug that reveals the slash-delimited path format. It still does not state whether the path must be full-depth, whether leading/trailing separators are allowed, or whether a bare category slug works.

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 essentially the tool name restated: "Category for a slug path" names no verb and does not say whether it resolves a slug to a category name, a breadcrumb trail, an ID, or a subtree. The single example clarifies input shape but not what the tool returns or does, and there is no differentiation from nearby tools such as category_products or product_filters.

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 mention of alternatives, and no stated precondition beyond the implicit requirement of a slug. An agent would have to guess whether this is the right tool for taxonomy lookups versus category_products or search_products.

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 does not state that this is a read-only listing operation, nor does it disclose pagination, sorting behavior, limits, or error conditions.

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 compact sentence with no filler, and the category context is front-loaded. It is concise, though the parenthetical source hint is the only extra detail provided.

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?

An output schema exists, so return-value details are less critical, but the tool still has five parameters with no schema descriptions and no annotations. The description is too sparse to fully explain pagination, sorting, and listing 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 description coverage is 0%, so the description must compensate for five undocumented parameters. It only clarifies where category_id values come from and says nothing about page, sort, limit, or direction.

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 identifies the resource as products within a category, which distinguishes it from general product search and from brand/label product tools. It lacks an explicit verb such as 'list', but the intent is still easy to infer.

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 implies when to use the tool by saying products are retrieved by category, and it helpfully explains where category IDs come from. However, it does not explicitly compare this tool with search_products, brand_products, label_products, or product_filters.

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 supplied, so the description carries the full burden. It does disclose one real behavioral fact beyond the schema — that authentication is required — and implies a read-only aggregate view, but says nothing about session/state sensitivity, whether the context is cached or live, or failure modes when no active basket 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?

A single compact line with the resource name front-loaded and contents listed after the colon; nothing is wasted. It is slightly cryptic as a fragment ('v4' is unexplained) but well structured for its length.

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?

An output schema exists, so return values need not be explained, and with zero parameters the tool is mechanically simple. However, in a sibling set dense with checkout_* tools, the description leaves the agent guessing which one to call, which is the main completeness gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. The baseline of 4 applies since no parameter semantics are 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 names the resource ('Checkout context') and enumerates its contents: basket, slot, payment, totals. That is specific enough to know what comes back, but it never distinguishes itself from close siblings like checkout_summary, checkout_payment_options, checkout_timeslots, or checkout_delivery_addresses.

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 only guidance is the prerequisite 'Requires login'. There is no statement of when to prefer this aggregate context over the granular checkout_* siblings, and no exclusions or call-order advice for a checkout 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?

No annotations are supplied, so the description carries the full burden; it does disclose the auth requirement and that results are scoped to the current checkout. It does not state that the operation is read-only or what happens when no checkout is active, leaving some behavioral gaps for an unannotated tool.

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

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

Two short sentences, front-loaded with what is returned and followed by the precondition. No filler, though the phrasing is telegraphic and could have stated the verb explicitly at no extra length.

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

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

With no parameters and an output schema covering return values, the description only needs to convey scope and access rules, which it does. The remaining gap is the relationship to the nearby redemption and wallet tools, which it leaves unstated.

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 and the baseline applies. The scope statement ('current checkout') usefully explains why no parameter 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 names a specific resource (Cumulus bons) and scopes it to those redeemable in the current checkout, which separates it from the broader cumulus_bons and cumulus_bon siblings. The verb ('returns'/'lists') is implicit rather than stated, but the noun phrase plus scope is unambiguous.

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

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

It states a prerequisite ('Requires login') and implies the context where it applies (an active checkout). It does not name an alternative such as cumulus_bons for the full wallet, or redeem_cumulus_bon for the actual redemption action, so the agent must infer the boundary.

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 present the description carries the full burden, and it does disclose one genuinely behavioral fact: login is required. The read-only, non-destructive nature is strongly implied by 'available' and returns are covered by the output schema, but nothing is said about whose addresses are returned or whether an unauthenticated call errors or returns empty.

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

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

Two short sentences with no wasted words, and the resource statement is front-loaded ahead of the login caveat. It is efficient almost to a fault: the terseness is what leaves the gaps noted elsewhere.

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 tool with an output schema and no annotations, the description covers the essentials (what it returns, that auth is needed) but omits the one thing that matters most in this sibling set: how these addresses relate to my_addresses and the other checkout_* tools.

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

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

The tool takes zero parameters and schema coverage is 100%, so there is no parameter meaning for the description to add; the baseline for a parameterless tool 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 names the resource ('delivery addresses') and scopes it to checkout, which hints it differs from the broader my_addresses sibling, but it is a noun phrase with no verb and never states plainly that it lists/returns addresses rather than, say, validating one. An agent can guess the purpose but must infer the operation.

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?

'Requires login' is the only guidance and it is a prerequisite, not a usage rule. Nothing says when to call this instead of my_addresses, my_address, or delivery_info, even though those siblings plausibly overlap on address data.

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 behavioral burden. It discloses that login is required, which is useful, but it does not explicitly state that the operation is read-only, what side effects exist, or what safety profile the agent should expect.

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 extremely short, front-loaded, and free of filler. Both sentences are directly relevant, though the first sentence is terser than an ideal purpose statement.

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 a simple zero-parameter query and an output schema exists, so return values need not be described. However, the description omits the checkout flow context and any sibling differentiation, leaving the agent to infer when in the checkout sequence this tool is appropriate.

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 for the description to explain. The baseline score of 4 applies because the empty schema leaves nothing ambiguous.

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 noun phrase that essentially restates the tool name, with no explicit verb such as 'list' or 'get'. It indicates the resource is checkout payment options, but it does not distinguish the tool from checkout-context siblings like checkout_context or checkout_summary.

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 only guidance is the login prerequisite; there is no indication of when to call this tool versus checkout_context, checkout_summary, or other checkout-stage tools. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden, yet it only discloses that login is required. It does not say whether this is a read-only snapshot, whether it mutates or locks checkout state, or what "verified" implies about validity of the summary.

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

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

Two short sentences with no filler, but their brevity comes from under-specification rather than economy. The auth constraint is front-loaded, which is the one structural positive.

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?

An output schema exists, so return values need not be described, and there are no parameters to cover. Still, an agent cannot tell from "checkout summary" what state this represents or where it fits in the checkout sequence alongside its many siblings, leaving the core question unanswered.

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 meaning to add; the baseline of 4 applies. The description does not need to explain arguments at all.

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?

"Checkout summary" essentially restates the tool name, and "Verified" adds an unexplained qualifier. The description never states what the summary contains (items, totals, fulfilment state?) or how it differs from siblings such as checkout_context or checkout_payment_options.

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 only guidance is the precondition "Requires login," which says nothing about when this tool should be chosen over checkout_context, checkout_cumulus_bons, or the other checkout-step tools. No alternatives or exclusions are 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?

No annotations are provided, so the description carries the full burden; it does disclose the authentication requirement, which is genuinely useful behavioral context. However it doesn't state side-effect freedom, whether slots are user/order-specific, or any rate/scope constraints, leaving notable gaps for a no-annotation tool.

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

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

Two short sentences with no filler, and the subject is stated before the login prerequisite. Nothing is redundant.

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?

Complexity is minimal: no parameters, and an output schema exists so return values need not be described. The main remaining gap is disambiguation from sibling slot/delivery tools, which the description doesn't 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?

The tool takes zero parameters, and 100% schema coverage means there is no parameter meaning for the description to add. Baseline 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 description names the resource (checkout timeslots) but is a bare noun phrase with no verb and no scope, so it's unclear whether it lists slots, reserves them, or reports availability. It also doesn't differentiate from sibling tools such as my_delivery_slots, delivery_info, or fulfilment_selection, which an agent would need to choose between.

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 only guidance is a prerequisite ('Requires login'), with no statement of when to call this versus my_delivery_slots or the other checkout_* tools. Usage is implied by 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?

With no annotations supplied, the description carries the full burden. It does disclose two real behavioral traits beyond the schema: this is a persistent Firestore write, and it is gated behind a confirm=true safety flag. It still omits permissions, reversibility of the tick, and any side effects on list counters or members.

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

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

Two short sentences with zero filler, and the primary action is front-loaded ahead of the confirm requirement. Nothing needs cutting; the brevity is limited only by how little it says.

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 output schema but no annotations and 0% parameter coverage, the description leaves too much unstated: the meaning of completed=false, what confirm guards against, and what authorization or list membership is required. The presence of an output schema excuses it from explaining returns, but not from the input and safety gaps.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It covers only confirm, and while 'tick (or untick)' hints at the completed boolean with its default of true, it never states that mapping explicitly, nor does it say what list_id and item_id address.

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 a specific verb pair ('tick/untick') and a specific resource ('shopping-list item'), which clearly separates it from add_shopping_list_item and remove_shopping_list_item. It stops short of explicitly naming those siblings or stating its scope relative to 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 when-to-use guidance: nothing tells the agent to prefer this over add/remove_shopping_list_item or shopping_list_items when the goal is toggling state. The only usage-like statement, 'Needs confirm=true', is a hard requirement rather than contextual guidance, and no exclusions or prerequisites are given.

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

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

No annotations are provided, so the description carries the full behavioral burden and it discloses almost nothing: not whether the call is read-only (implied only by the prepositional phrase), not auth requirements, and not what happens when the id is unknown. With an output schema present, return shape is partly covered elsewhere, but the failure and permission behavior remains undocumented.

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 it is a noun fragment rather than a front-loaded sentence, and the brevity comes from under-specification rather than efficiency. There is nothing to front-load because no useful information is present.

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 low-complexity with one required parameter and an output schema, so the bar is modest, yet the definition still omits id format, read-only nature, and error behavior. An agent could construct the call but could not confidently predict what it does or how to handle failure.

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 compensate for the lone page_id parameter and does not. It never states whether page_id is a numeric CMS id, a UUID, or a slug, nor any format constraint — "by id" adds no meaning beyond the parameter name itself.

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?

"A CMS content page by id" is essentially a restatement of the tool name plus the single required parameter; there is no verb and no statement of what retrieving the page yields. It is distantly distinguishable from the sibling list only because none of them mention CMS content, not because the description differentiates it.

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, when-not-to-use, or alternative-tool guidance. An agent gets no signal about whether this is for fetching marketing copy, navigation structure, or embedded page data, nor any prerequisite.

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

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

With no annotations, the description must carry the behavioral burden; it implicitly frames this as a read-only lookup and the example ('8001' -> gmzh) hints at the return shape. It does not state what happens for an unknown or ambiguous postcode/town, or whether the lookup is exhaustive across regions.

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 an inline example, front-loaded and free of padding. It is arguably too terse rather than verbose, but every element present earns its place.

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

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

For a one-parameter lookup with an output schema, the core is covered, but edge-case behavior (unknown/ambiguous input, multiple cooperatives per region) and the relationship to sibling store/address tools are absent. Adequate but with clear gaps.

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

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

Schema coverage is 0% for the single parameter, so the description must compensate, and it does: it clarifies that the field accepts either a postcode or a town name and provides a concrete example value. This meaningfully extends beyond the bare 'Zip Or City' string property.

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 identifies the resource ('The Migros cooperative') and the input it maps from ('a postcode or town'), with a concrete example ('8001' -> gmzh). However, there is no explicit verb such as 'look up' or 'resolve', and nothing distinguishes it from sibling lookups like find_stores or address_search.

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

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

No guidance is given on when to use this tool versus alternatives such as find_stores, store_availability, or address_search, nor any prerequisites or exclusions. The agent must infer the use case entirely from the one-line purpose.

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

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

With no annotations supplied, the description carries the full disclosure burden. It does add one genuinely useful behavioral fact — that authentication is required — but says nothing about read-only safety, error behavior when logged out, or freshness of the balance.

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

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

Two short sentences, front-loaded with the resource and followed by the auth requirement; nothing is padded. It is arguably too terse rather than verbose, but every sentence earns its place.

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

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

For a zero-parameter tool that has an output schema, the description covers what is returned and the auth requirement, which is close to sufficient. However, the account-vs-Cumulus scope ambiguity is left unresolved, which matters given how many overlapping wallet and points siblings exist.

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 declares zero properties at 100% coverage, so there is nothing for the description to clarify. Baseline 4 applies for a parameterless tool; the description at least confirms it is account-scoped with no inputs.

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 resource — the Migros account credit balance — so the agent knows it returns a monetary/credit figure rather than points or bons. It does not explicitly distinguish itself from near-neighbours like cumulus_points, cumulus_wallet, or cumulus_bons, which is the only thing keeping it from 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?

'Requires login' is a precondition, but there is no guidance on when to choose this tool over the many other balance/wallet-style siblings. No exclusions, no alternatives, no statement about what happens if the agent is unauthenticated.

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 the login requirement, which is useful, but says nothing about whether the operation is read-only, what data is exposed, or any other behavioral traits.

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 only two short sentences and has no bloated wording. However, the first sentence mostly restates the tool name, and the structure offers little beyond the login note.

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 presence of an output schema reduces the need to explain return values, but the input schema has no parameter descriptions and there are no annotations. For a two-parameter tool, the description is too incomplete about parameters and sibling differentiation.

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%, and the description says nothing about either bon_id or full. It does not clarify what identifier format is expected or what setting full=true changes.

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 essentially a restatement of the tool name with 'single' added. It does not state an action such as retrieve or fetch, so the agent must infer that this returns one Cumulus bon rather than doing something else with it.

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 only guidance is 'Requires login,' which is an authentication prerequisite, not usage guidance. It does not explain when to use this instead of the sibling cumulus_bons or other bon-related tools.

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

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

With no annotations, the description carries the full disclosure burden. It does state the authentication requirement, which is useful, but says nothing about whether the call is read-only (implied but unstated), rate limits, or what 'full' changes in the response.

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

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

Two short sentences with no padding and the resource identified immediately. The brevity is efficient rather than rambling, though it edges toward under-specification.

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?

An output schema exists, so return values need not be explained, but for a voucher-retrieval tool sitting among many cumulus_* siblings the description omits the key discriminating detail: what makes this different from cumulus_bon and what 'full' does.

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 single parameter 'full' has 0% schema description coverage and the description adds no meaning beyond it. An agent cannot tell whether 'full' expands nested voucher details, includes redeemed/expired bons, or alters response size.

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 a specific resource ('Cumulus bons (cash vouchers)') and clarifies the local term with a parenthetical, but uses no verb, so the agent must infer that this is a read/list operation. It also fails to differentiate from the near-identical sibling 'cumulus_bon' (singular), which is exactly the ambiguity an agent needs resolved.

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?

'Requires login' is a genuine prerequisite, but there is no guidance on when to call this versus cumulus_bon, cumulus_wallet, cumulus_coupons, or checkout_cumulus_bons. The agent is left to guess from names 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 supplied, so the description carries the full disclosure burden; it does add the auth requirement ('Requires login'), which is genuinely useful context beyond the schema. It omits other traits an agent would want for a read: read-only nature, behavior when the id is unknown, and any error conditions. With zero annotation coverage this is thin, but the auth note earns partial credit.

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

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

Two short clauses, front-loaded with the resource and scope, then the prerequisite; nothing is wasted. The terseness is close to under-specification, but as a structure/economy measure it is efficient.

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?

An output schema exists, so return values need not be described, and the auth requirement is covered. Given a 2-parameter tool with one undocumented flag and no differentiation from cumulus_coupons, the definition is barely 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 0% for two parameters, so the description must explain them. It only gives meaning to unique_id ('by unique id'); the `full` boolean is completely undocumented in both schema and description, leaving the agent unable to tell what it changes about the response.

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?

"A single Cumulus coupon by unique id" identifies the resource and the retrieval scope (singular, keyed by id), which distinguishes it from the sibling list tool cumulus_coupons and from activate_coupon/deactivate_coupon. The only weakness is the absence of an explicit verb such as 'Fetch' or 'Retrieve', so the operation type is inferred 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?

"Requires login" is a concrete prerequisite, and 'by unique id' implies the tool is for looking up one known coupon. However, there is no explicit guidance on when to use this instead of cumulus_coupons (to enumerate coupons) or the activate/deactivate siblings, so the agent must infer 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?

With no annotations, the description carries the full burden and does disclose two behavioral facts: authentication is required and the result is limited to activated/available coupons. It does not state that the call is read-only and non-mutating, nor anything about result volume or ordering.

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

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

Two short sentences, front-loaded with the resource and followed by the auth prerequisite. No wasted wording, though the terse phrasing leaves no room for the parameter clarification that is needed.

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?

An output schema exists, so return values need not be explained, and the login prerequisite covers the main usage constraint. The unresolved gap is the two undocumented boolean flags, which for a simple read tool is the one thing an agent most needs help with.

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%: 'full' and 'with_preview' are bare booleans with defaults and the description says nothing about either. An agent has to guess that 'full' widens the payload and 'with_preview' controls preview data, which is exactly what the description should have settled.

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 the specific resource (Cumulus coupons) and narrows scope with the parenthetical '(activated and available)', so an agent knows what set it returns. It does not distinguish itself from the singular sibling cumulus_coupon or from partner_coupons, leaving some ambiguity for selection.

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?

'Requires login' gives a concrete prerequisite for calling it, which is genuinely useful. However, there is no guidance on when to use this list versus cumulus_coupon (presumably a detail view) or partner_coupons, and no note on when-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?

No annotations are supplied, so the description carries the full behavioral burden; it does disclose the authentication prerequisite, which is genuinely useful context. However, it says nothing about what login mechanism is expected, whether results are cached or live, or how much history is aggregated, leaving real gaps for a no-annotation tool.

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

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

Two short sentences with the subject front-loaded and no filler; the scope is stated before the prerequisite. It is efficient rather than padded, though the terseness is partly what leaves the 'full' flag unexplained.

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?

An output schema exists, so return values need not be described, and the login prerequisite is flagged. The definition is still incomplete for a points tool because the sole parameter is left undefined and the sibling relationship is unaddressed.

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 single parameter 'full' has zero schema description coverage and the description never mentions it, so the agent must guess whether it expands the period range, adds transaction detail, or changes the response shape. With coverage below 50%, the description is expected to compensate and it does not.

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 a specific resource (Cumulus points and spend) and its temporal scope (current and previous periods), so an agent knows exactly what data comes back. It does not distinguish itself from nearby siblings such as cumulus_profile, cumulus_wallet, or cumulus_wrapped, which an agent could easily confuse with a points-balance 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 only guidance is the prerequisite 'Requires login', which tells the agent the call will fail unauthenticated but not how to satisfy it. There is no statement of when to prefer this over cumulus_wallet or cumulus_profile, and no exclusions or alternatives offered.

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 supplied, so the description carries the full burden, and it does disclose the login requirement — a genuinely useful behavioral trait. It leaves unstated that the operation is a safe read and what happens if the session is unauthenticated, so the disclosure is partial rather than complete.

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 terse clauses, front-loaded with the resource and its payload, with the auth constraint appended. Nothing is wasted, though the extreme terseness is part of why the 'full' parameter goes unexplained.

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?

An output schema exists, so return-value detail is not required, and the auth note covers the main call precondition. For a tool with one undocumented parameter and no annotations, however, the description should have explained the 'full' flag and distinguished the tool from neighboring profile and loyalty endpoints.

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 single parameter 'full' has a boolean type, a default and zero schema description coverage, and the description never mentions it. The agent is told which fields come back but not what toggling 'full' changes, which is the only ambiguity an agent faces when invoking this 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 description names a specific resource and enumerates the returned attributes: card number, memberships, lifestage. That is enough to distinguish it from data-only siblings such as cumulus_points or cumulus_wallet, though it never explicitly contrasts itself with the adjacent my_profile 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?

'Requires login' implies an authentication precondition, which is a small piece of context. Beyond that there is no guidance on when to call this instead of my_profile, cumulus_wallet or cumulus_points, and no explanation of when the 'full' variant is appropriate.

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 load: it does disclose the authentication requirement and 'overview' implies a read-only summary. It does not say what the 'full' flag changes behaviorally, nor anything about scoping, caching, or failures beyond the login requirement.

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 front-loaded sentence listing the returned content, followed by the login prerequisite. No padding, though the space saved could have been spent on the undocumented 'full' flag.

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?

An output schema exists, so return values need not be described, but the tool's only parameter is left undefined and no routing against the many cumulus_*/stampcard siblings is given. For an aggregator with an undocumented toggle, this leaves an agent guessing.

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% and the single parameter 'full' (boolean, default false) is never mentioned in the description. The one thing the schema cannot convey — what 'full' expands or includes — is entirely absent.

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 a concrete resource and its contents: a wallet overview returning points plus coupon/voucher/stampcard counts. That is more specific than a restated name. It does not, however, distinguish itself from siblings like cumulus_points, cumulus_coupons, or stampcards, which return overlapping data.

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?

'Requires login' is a prerequisite, not a when-to-use rule. Nothing says whether to call this aggregator first and then drill into cumulus_points / cumulus_coupons / stampcards, or when to prefer this over those single-resource 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the login requirement and the content areas included, but it does not clarify read-only behavior, the time window covered, or what the 'full' option changes.

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 short and front-loads the purpose before the login requirement. It is efficient and readable, with only minor framing that is slightly marketing-oriented rather than purely operational.

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?

Because an output schema exists, the description need not explain return values. It still leaves gaps around the 'full' parameter and broader behavior, but it is adequate for a simple read-oriented summary tool.

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

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

The only parameter, 'full', is not mentioned in the description at all, and the schema provides no description for it (0% coverage). The description therefore does not compensate for the missing parameter semantics, though the single optional boolean is relatively low-risk.

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 that this is a Cumulus 'year in review' covering top products, categories, shop, and savings. It does not explicitly distinguish itself from related siblings such as purchase_analytics or cumulus_points, but the annual-summary framing is specific enough for an agent to understand its purpose.

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

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

The description implies usage for an annual recap and states 'Requires login' as a precondition. However, it provides no explicit when-to-use guidance versus alternatives like purchase_analytics, nor any when-not-to-use exclusions.

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 does useful work by flagging that this 'Changes account state' and that confirm=true is required, which tells the agent this is a mutation gated behind an explicit flag. It stops short of saying whether deactivation is reversible, what happens to the coupon afterwards, or what confirmation semantics mean beyond passing true.

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

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

Two short sentences, with the action and target front-loaded and the safety precondition immediately after. Nothing is redundant and nothing could be trimmed 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?

For a state-mutating tool with no annotations, the essentials (target, mutation nature, confirm gate) are present, and an output schema exists so return values need no explanation. However, prerequisites such as authentication/Cumulus session requirements and the consequences or reversibility of deactivation are absent.

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 compensate: it explains that 'ean' identifies the coupon to deactivate and, critically, that 'confirm' must be true even though the schema defaults it to false. That is meaningful added semantics for both parameters, though EAN format/validation is not described.

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 ('Deactivate') plus a specific resource ('Cumulus coupon') and an identifier ('by EAN'), so the agent knows exactly what operation is performed. It does not explicitly name the sibling activate_coupon as the inverse, but the verb itself is unambiguous against that 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?

The description implies the use case (deactivating an existing coupon) and adds one concrete precondition ('needs confirm=true'), but gives no explicit when-to-use/when-not guidance or routing to alternatives such as cumulus_coupon for inspection first.

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 supplied, so the description carries the full behavioral burden. It does disclose the important confirm=true safety gate, which is genuine behavioral context, but it says nothing about whether deletion is permanent or recoverable, what permissions are needed, or whether the whole batch is deleted atomically if one id is invalid.

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

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

Two short sentences with the action front-loaded and no filler. The brevity is efficient, though it borders on under-specification rather than tightness.

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 destructive, multi-id mutation with zero annotations, the description is thin: it omits irreversibility, permission requirements, and batch behavior. The existence of an output schema relieves it of explaining return values, but the safety-critical context an agent needs before calling this is largely absent.

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 explain both parameters. It clarifies the semantics of confirm (must be true to act, overriding the schema's default of false), but message_ids — the required parameter — gets no explanation of format, source, or limits on how many ids may be passed.

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 a specific verb and resource ("Delete inbox messages"), which an agent can distinguish from siblings like inbox and mark_messages_read. It stops short of stating scope details such as single vs bulk deletion, but the core action is unambiguous.

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

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

The phrase "Needs confirm=true" implies this is a guarded destructive operation and tells the agent what is required to proceed. However, there is no explicit when-to-use guidance, no mention of alternatives (e.g., mark_messages_read when the intent is only to archive), and no statement of when the tool should not be used.

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 it discloses only the auth requirement. It does not state that this is a read-only lookup, what the response contains, or whether cut-off times vary by address/fulfilment context — meaningful gaps for a logistics-information tool.

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

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

Two short, front-loaded sentences with no filler — the resource is stated first and the auth prerequisite second. It is efficient, though it errs toward under-specification rather than 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?

An output schema exists, so return values need not be described, and a zero-parameter tool is low complexity. Still, the description omits how this differs from the several delivery/fulfilment siblings, leaving an agent to guess which one to 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?

The tool takes zero parameters, so there is no parameter meaning for the description to add; the baseline of 4 applies. The schema is empty and fully self-explanatory.

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?

"Delivery information and cut-off times" names the resource and adds one concrete content hint (cut-off times), but the operative verb is left implicit and "information" is close to restating the tool name. It gives no signal distinguishing it from siblings like my_delivery_slots, fulfilment_selection, or checkout_timeslots, which plausibly overlap.

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?

"Requires login" is a prerequisite, not usage guidance. There is no statement of when to call this versus my_delivery_slots or checkout_timeslots, and no exclusions or conditions are offered.

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 supplied, the description carries the full disclosure burden and provides almost nothing: it does not state that this is a read-only retrieval, whether authentication or a session is required, whether panels are personalized or region-specific, or how many are returned. Only the presence of an output schema saves it from being completely opaque.

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 fragment with no wasted words and the resource is front-loaded, but the terseness crosses into under-specification: there is no verb to anchor the sentence and no second clause adding the information an agent actually needs.

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?

Because an output schema exists, the description need not explain return values, and a one-parameter read tool is inherently simple. Still, it omits the read-only nature and the origin of the page id, leaving an agent to infer behavior it should have been told.

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 compensate for the single parameter, and all it offers is that the id refers to a 'page'. It does not say where a page id comes from (content_page, home_layout, a URL) or what format it takes, which is the key practical question for this call.

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 a resource ('retail-media display panels') and its key ('page id'), but it is a bare noun phrase with no verb, so it never says whether it fetches, lists, or creates panels. Several siblings (content_page, teasers, home_layout) serve related page-content purposes, and nothing here distinguishes it from 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 when-to-use guidance, no preconditions, and no mention of any alternative tool. An agent must guess whether this is the right call for page content versus content_page or teasers.

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 does disclose the meaningful auth constraint ("Requires login") and the priced nature of the returned data, which is real value beyond structured fields. It stops short of confirming this is a side-effect-free read or describing scope/pagination, but the tool is a zero-parameter listing and an output schema exists, so the remaining gap is moderate.

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

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

Two short sentences with no filler, and the resource statement is front-loaded ahead of the login prerequisite. Nothing here is redundant with the schema.

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

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

For a zero-parameter read tool with an output schema and no annotations, the description supplies what is missing: the content returned (favourite products with prices) and the authentication requirement. Only the differentiation from sibling favourites tools (is_favourite, add_favourite, my_products) is left unaddressed.

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 description does not need to compensate for any schema coverage gap (coverage is 100%).

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?

"Your favourite products, priced" identifies the resource (favourite products) and implies a listing with price data, so the verb/resource pair is inferable. However, it never states the operation explicitly (list/retrieve) and gives no differentiation from close siblings like my_products, is_favourite, add_favourite, or remove_favourite, leaving an agent to guess which of these surfaces the favourites collection.

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?

"Requires login" is a prerequisite, not usage guidance. There is no statement of when to choose this over my_products or is_favourite, and no exclusions or context about what a logged-in caller should expect to get back versus the 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?

With no annotations, the description carries the full behavioral burden, yet it says nothing about result limits (the default limit of 10 is undocumented), what happens when neither query nor coordinates are supplied, or whether query and coordinates can be combined. Only the basic retrieval semantics are conveyed.

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, and the search keys are presented before the coordinate alternative. It is arguably too terse for a 4-parameter tool, but nothing is wasted.

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

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

An output schema exists, so return values need not be explained, and the core inputs are named. Still, a search tool with four parameters at 0% schema coverage and no annotations should clarify the limit behavior and how query versus coordinates interact.

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 compensate; it does partly by mapping 'town, postcode or name' to the generic `query` parameter and 'coordinates' to latitude/longitude. However, it omits `limit` entirely and gives no format hints (e.g., postcode format, coordinate pair requirements, mutual exclusivity).

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 ('Find stores') plus the search keys (town, postcode, name, or coordinates), so an agent knows exactly what the tool retrieves. It does not distinguish itself from near-siblings like store_map, store_availability, or address_search.

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 when-to-use guidance and no mention of alternatives, even though store_map, store_availability, and address_search sit right beside it. Usage is only implied by the name and the list of search keys.

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 supplied, so the description carries the full behavioral burden. It does disclose one genuine behavioral trait the schema does not: when no postcode is supplied, the tool resolves against the guessed location rather than failing. However, it says nothing about whether this is a read-only lookup, what triggers the different fulfilment modes, whether results are cached or scoped to the session, or about permissions.

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 fragment is short and front-loaded, so it is efficient. But it is compressed to the point of ambiguity: the colon-separated "cooperative, warehouse, slot" reads as an unfinished enumeration with no framing verb, costing more clarity than the brevity saves.

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 zero annotation coverage, 0% schema description coverage, and heavy overlap with a large set of fulfilment/location/delivery siblings, the description does too little. An output schema exists, so return values need not be explained, but the routing information an agent needs to choose this tool over delivery_info or my_fulfilment_selection is absent.

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% for the single zip_code parameter, so the description must compensate. It labels the parameter as a postcode and explains that omitting it falls back to a guessed location, which is real meaning beyond the bare nullable string in the schema. It does not specify format expectations (postal code vs. country prefix) or how an incorrect postcode is handled.

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 identifies the resource as "delivery context for a postcode" and hints at the returned dimensions (cooperative, warehouse, slot), so the general area is graspable. But there is no verb and no statement of what the tool actually does with that context, and the trailing list is too terse to be certain whether those are returned mode types or input options. It is not distinguished from close siblings such as delivery_info, my_fulfilment_selection, or checkout_timeslots.

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 at all: no statement of which situations call for this tool versus delivery_info, store_availability, checkout_timeslots, or my_fulfilment_selection. The parenthetical "or the guessed location" hints at a fallback but not at when the caller should pick this tool over the alternatives.

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 supplied, so the description carries the full burden. It identifies a creation action and a confirm gate, but does not disclose permissions, side effects, reversibility, rate limits, or what happens when confirm is false.

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 front-loaded sentences with no filler. Both sentences carry actionable information: what is created and the required parameter 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?

An output schema exists, so return-value explanation is appropriately omitted. For a one-parameter create tool the call basics are covered, but with no annotations the missing behavioral and alternative guidance leaves it somewhat incomplete.

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 single boolean parameter has 0% schema description coverage, and the description supplies the essential value constraint: confirm=true is required. It does not explain why confirm is needed or what false does, but it adds the critical meaning the schema lacks.

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 ('Create') and resource ('Google Wallet pass JWT') tied to the Cumulus card. It distinguishes the create action from the sibling google_wallet_pass_status by verb, though it does not explicitly name any 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?

It provides a precondition ('Needs confirm=true') but does not explain when to choose this tool over apple_wallet_pass, google_wallet_pass_status, or other wallet tools. Usage is implied by the create verb, but no exclusions or alternatives are given.

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

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

With no annotations supplied, the description carries the full disclosure burden; it does add real value by declaring the login/authentication requirement and by framing the operation as a non-mutating status query. It says nothing about what happens when the card is absent or the user is logged out, and does not describe error or empty-state behavior. Given an output schema exists, the missing return-value detail is excusable, but the auth and no-side-effect context is the only behavior surfaced.

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 earning their place: the first defines the result, the second states the gating prerequisite. The purpose is front-loaded and there is no filler.

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

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

For a zero-argument, read-only status check with a declared output schema, the description covers what the agent needs: the subject (Cumulus card in Google Wallet) and the auth prerequisite. Only minor gaps remain around logged-out/not-saved handling, which the output schema likely covers anyway.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. The description correctly implies the call needs no arguments by scoping everything to 'your' Cumulus card.

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 query and resource: returning whether the Cumulus card is saved to Google Wallet. The singular noun 'status' plus the 'Whether...' framing makes clear this is a read of state, not a creation flow, which implicitly separates it from google_wallet_pass. It stops short of explicitly naming that sibling or the Apple Wallet counterpart, so the differentiation is inferred rather than stated.

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

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

The only guidance is the prerequisite 'Requires login', which is genuinely useful for gating the call. There is no explicit statement of when to prefer this over google_wallet_pass (e.g. to check before adding) or apple_wallet_pass, so the agent must infer usage from the name. Adequate but thin.

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 supplied, so the description carries the full disclosure burden. It does add real signal — that the payload is time-of-day partitioned (morning/afternoon/evening) and cooperative-scoped — but it never states that the operation is read-only or whether results depend on which cooperative is currently active.

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 well-formed sentence with the scoping condition and the variant structure front-loaded. Nothing is wasted and nothing essential is buried.

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

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

With an output schema present, return values need no explanation, and a zero-parameter getter needs little more than resource identification. The only meaningful omission is the implicit dependency on an active cooperative, which the description gestures at ('your cooperative') without explaining.

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 parenthetical about morning/afternoon/evening is the closest thing to parameter meaning, hinting at how the returned data is segmented.

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 the exact resource — the app's greeting texts — and scopes it to 'your cooperative' with a parenthetical explaining the morning/afternoon/evening variants. It is not a verb-first statement, but for a zero-parameter retrieval tool the resource identification is unambiguous and distinguishes it from siblings like inbox or content_page.

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 an agent should call this versus alternatives (e.g., content_page, home_layout, inbox), nor any precondition such as needing an active cooperative selected first. Usage is only inferable from the noun phrase itself.

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 it only obliquely signals an unauthenticated/guest context. It says nothing about whether this is a read-only lookup, whether it depends on session or location, how it is cached, or what happens if the layout is unavailable.

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 sentence with no wasted words and the resource is front-loaded. However, the brevity comes from under-specification rather than economy, so it is concise but not informative.

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?

An output schema exists, so return values need not be explained. Still, for a tool with an undocumented 'entry' parameter, no annotations, and several plausible siblings, the definition omits the guest-session context, the meaning of 'entry', and why one would pick this over home_products or display_panels.

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% for the single 'entry' parameter, so the description must compensate, and it does not mention the parameter at all. An agent is left to infer that 'entry' selects a layout entry point and that its default 'home' is valid, with no idea what other values are accepted.

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

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

The description names a resource (CMS home layout) and a scope (for guests), which lets an agent guess it returns merchandising/content layout data rather than products. But it has no verb (fetch/retrieve) and does not distinguish it from near neighbors like home_products, display_panels, or content_page, leaving the specific purpose vague.

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 or when-not-to-use guidance at all. The phrase 'for guests' hints at an unauthenticated context but is never tied to a decision such as 'use this instead of home_products when the session is not logged in', and no prerequisite or alternative is 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?

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about whether the call is read-only, requires authentication, is user-specific, or how results are ordered. The only behavior conveyed is that the content corresponds to a home-screen slider, which is a restatement of the name rather than added 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 single sentence is tight and wastes no words, but the brevity comes from omission rather than precision. There is no front-loaded verb or scope statement to anchor the agent before it reads the 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?

An output schema exists, so return values need not be explained, but for a tool with no annotations and an undocumented parameter the description should still cover access/auth expectations and how it differs from the many product-listing siblings. It supplies none of that, leaving the definition materially incomplete.

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 one parameter, limit, with a default of 12 and 0% schema description coverage, and the description never mentions it. The agent cannot tell from either source whether limit caps the number of slider items returned or has some other effect, so the description fails to compensate for the coverage gap.

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 a resource — the product slider on the app's home screen — which implies it returns the products featured in that slider. However, it is a noun phrase rather than a verb+resource statement, and it does not distinguish this from nearby siblings like home_layout, product_cards, my_products, or new_products, which plausibly return overlapping content.

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 home_layout, product_cards, new_products, or my_products — all of which could surface home-screen or featured products. No prerequisites, no exclusions, no mention of whether this is personalized or guest-accessible, so an agent must guess 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?

With no annotations, the description carries the full burden and does disclose the authentication requirement, which is a real behavioral constraint. However, it says nothing about whether reading the inbox mutates state (e.g. auto-marking messages read), ordering, or volume limits, all of which matter for a message-list endpoint.

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

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

Two short sentences with the resource stated first and the auth caveat second; nothing is padded. The parenthetical '(campaign messages)' is efficient disambiguation rather than filler.

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

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

Complexity is low (one optional boolean, no nesting) and an output schema exists, so return values need not be explained. Still, the undefined 'full' flag and the absence of any read-vs-mark-read clarification leave an agent short of what it needs to invoke this 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 0% and the single parameter 'full' is a bare boolean with no description. The tool description never mentions 'full' at all, so an agent has no way to know whether it means full message bodies versus a summary, or full history versus unread. This is the clearest gap in the definition.

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 identifies the resource precisely as 'your message-center inbox' and narrows it to 'campaign messages', which usefully disambiguates it from a generic messaging endpoint. It does not name or contrast with the related siblings mark_messages_read or delete_messages, so an agent must infer the relationship.

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?

'Requires login' is the only contextual signal, and it is a prerequisite rather than a when-to-use rule. There is no guidance on when to call this versus mark_messages_read or delete_messages, and no hint about what the 'full' flag changes about the listing.

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 supplied, so the description carries the full behavioral burden; it does disclose the authentication requirement, which is the single most important operational fact. It does not state that the call is a non-mutating status check, nor does it describe error behavior for guests or missing products. Given the output schema exists, return-shape details are not expected here.

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

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

Two short sentences with no filler, and the core purpose is front-loaded ahead of the login constraint. The first sentence is a fragment rather than a complete statement, which slightly weakens clarity for no length savings.

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?

This is a low-complexity single-parameter status check with an output schema, so the description need not explain return values. Purpose plus the login prerequisite covers most of what an agent needs; only the identifier format and behavior for invalid inputs remain unstated, which are minor for this complexity level.

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 one required parameter with 0% schema description coverage, so the description should compensate but largely does not. The phrase 'a product' loosely ties to product_id, and the parameter name is self-explanatory, but the description adds no detail on whether the identifier is a numeric ID, slug, or SKU, nor whether the product must exist.

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

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

The description names the specific resource (a product) and the specific predicate being evaluated (favourite status), so an agent can distinguish it from siblings like favourites, add_favourite, and remove_favourite. It is phrased as a fragment ('Whether a product is a favourite') rather than an explicit verb, but the meaning is unambiguous.

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

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

The prerequisite 'Requires login' gives the agent a gating condition, which is genuinely useful. However, there is no guidance on when to call this versus favourites (the list) or add_favourite/remove_favourite, and no mention of behavior for unknown or invalid product IDs.

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 supplied, the description carries the full behavioral burden and mostly fails it: it does not state that this is a read-only lookup, does not say what happens for an unknown slug (error vs. empty), and does not indicate whether the label payload includes linked products or metadata. The only behavioral hint is that lookup is keyed by slug.

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 resource identification is front-loaded ahead of the example value. It is terse to the point of under-specification, but nothing is wasted.

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

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

An output schema exists, so return values need not be described, and the tool is a simple one-parameter lookup. Still, the absence of any annotations plus no usage or slug-provenance guidance leaves meaningful gaps for an agent deciding whether and how to call it.

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% for the single 'slug' parameter, so the description must compensate. It does partially, by giving a concrete example value ('bio-knospe') that reveals the slug format, but it never says where to obtain valid slugs (presumably from label_products) or how slug matching behaves.

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 identifies the resource ('Label (certification) page') and clarifies that 'label' means a certification such as 'bio-knospe', which helps disambiguate from retailer-name meanings. However, the action is only implied by 'by slug' — there is no explicit verb like 'fetch' or 'retrieve' — and it never distinguishes itself from the sibling label_products, which operates on the same label concept.

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 statement of prerequisites, and no mention of the obvious alternative (label_products for listing products under a label). The agent must infer both the purpose and the routing decision 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?

With no annotations, the description carries the full burden and only discloses that results are paginated and include pricing. It says nothing about auth requirements, behaviour for an unknown slug, default page size, or total-count semantics — all relevant for a listing endpoint.

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 fragment has zero wasted words, but it is under-specified rather than concise — it reads like a subtitle, not an instruction. There is no front-loaded verb or structural separation of purpose versus behaviour.

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 five-parameter listing tool with no annotations and no schema descriptions, an output schema only relieves the need to document return values. An agent still lacks the slug semantics, sorting behaviour, and usage context needed to call this 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 0% across five parameters, so the description should compensate and does not. "Paginated" vaguely gestures at limit/offset, but slug, sort, and direction (including the asc/desc convention) remain completely undefined.

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?

"Products carrying a label" essentially restates the tool name label_products; there is no verb (list/retrieve) and no differentiation from the sibling label_detail. The phrase "priced and paginated" adds a hint about the result set but not a distinct purpose.

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

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

No when-to-use guidance is given and no alternative is named, even though siblings like category_products, new_products, brand_products, and label_detail clearly overlap. The agent must guess whether this is the right tool for browsing by label.

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 supplied, so the description carries the full behavioral burden. It does disclose a genuine trait beyond the schema — the authentication requirement — but says nothing about behavior when no prior order exists, whether cancelled orders count as 'last,' or any rate/permission constraints.

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

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

Two short sentences, resource first and prerequisite second, with zero filler. Nothing wasteful for the amount of content present.

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?

An output schema exists, so return shape need not be described, and login is covered. However, the unexplained 'full' flag leaves a real gap for a tool whose only knob is that flag.

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% and the single parameter 'full' (boolean, default false) is never explained. The agent cannot tell whether 'full' expands line items, address, payment info, or something else, which materially affects the response and possibly cost.

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 resource with a narrowing qualifier: 'Your most recently placed order,' which implies a single-record fetch as opposed to the list returned by the sibling my_orders. It does not name order_detail or my_orders explicitly, so the differentiation is implicit rather than stated.

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

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

The prerequisite 'Requires login' is a useful usage condition, but there is no guidance on when to pick this over my_orders, order_detail, or order_invoice, which all deal with orders. The agent must infer the choice from the word 'last.'

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 it usefully discloses that confirm=true is required despite the schema defaulting it to false. However, it says nothing about permissions/auth, whether the change is reversible, batching limits on message_ids, or what happens with unknown IDs.

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

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

Two short sentences with the operation front-loaded and the prerequisite immediately following; no filler. It is perhaps over-terse given the total absence of annotations, but every sentence earns its place.

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

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

An output schema exists, so return values needn't be described, and the mutation is simple with only two parameters. Still, for an unannotated write operation the description is thin — missing side-effect, idempotency, and permission context an agent would want before calling.

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 compensate for both parameters. It clarifies confirm's semantics (must be true even though the schema defaults to false), which is real added value, but message_ids is entirely unexplained — no format, limits, or behavior for invalid IDs.

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 combination ('Mark inbox messages as read') that clearly identifies the operation and the object it acts on. It does not explicitly contrast with the closest sibling, delete_messages, but the distinction is inferable.

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

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

The description gives one hard prerequisite ('Needs confirm=true'), which is actionable, but offers no when-to-use vs when-not guidance and no mention of the sibling delete_messages. Usage is implied by the verb rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. 'List' plus the returned fields convey that this is a read-only lookup whose payload includes each endpoint's auth requirement, and 'verified' hints the catalogue is curated/static, but nothing is said about result volume, pagination, or whether the catalogue changes at runtime.

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 core purpose is front-loaded in one sentence and the parameter note follows in a short args block. Every element, including the example prefixes, earns its place; nothing is redundant.

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?

An output schema exists, so return-value detail is unnecessary, and a one-optional-parameter lookup tool is simple enough that the description covers what an agent needs. The only shortfall is the absent guidance on how this catalogue relates to migros_request for actual invocation.

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 explain the single parameter – and it does: 'service' is described as an optional prefix filter with five concrete example prefixes (product-discovery, retentionapi, checkout, shopping-list, onelist, recipe). That is genuinely more informative than the bare string schema, though it doesn't state matching case-sensitivity or behavior for non-matching prefixes.

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

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

States a specific verb and resource: 'List the verified endpoint catalogue', and parenthetically names the record fields it returns (method, path, auth requirement). This makes the tool's nature as a static discovery/catalogue lookup clear and separable from action-oriented siblings like migros_request, though it never explicitly names that alternative.

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

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

Usage is only implicit: a 'catalogue' tool is understood to be for discovering available endpoints, likely before calling migros_request. There is no explicit when-to-use, when-not-to-use, or statement of the relationship to the sibling request tool, so an agent must infer the workflow.

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 disclosure burden, and it delivers the one non-obvious trait: the tool alone cannot finish the OAuth flow because PKCE requires a browser, so this is a partial-step tool. It does not state whether the call is read-only, whether it requires prior authentication, or whether the URL exposes secrets, which keeps it 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 short sentences with the primary action front-loaded and the follow-up constraint second. Nothing is wasted, and the key caveat is not buried.

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

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

An output schema exists, so return values need not be narrated here. For a zero-parameter, read-style helper, the description covers what the tool produces and how the flow finishes. The phrase 'client parameters' remains loosely specified, but the output schema likely resolves that.

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

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

The tool takes zero parameters, so the schema-coverage baseline of 4 applies. The description cannot add parameter meaning beyond the empty schema, and it correctly does not pretend 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?

States a specific verb and resource: 'Show the OAuth authorize URL and client parameters this device would use.' An agent understands it retrieves an OAuth URL rather than performing the login. It does not differentiate itself from auth-adjacent siblings such as migros_status or migros_request, but no sibling is close enough to create real ambiguity.

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

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

The second sentence implicitly sets the usage boundary by directing the agent to complete the flow with the local `migros-login` CLI because PKCE needs a browser. That is useful routing information, but there is no explicit 'use this when...' statement and no mention of prerequisites such as an existing session or device identity.

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

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

With no annotations, the description carries the full burden and does well: it discloses input guardrails (absolute URLs and '..' segments are refused), the confirmation gate ('confirm: required for every non-GET call, catalogue keys included'), and the method defaulting rule. It omits auth requirements, rate limits, and error behaviour, so it is not exhaustive.

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 one-line purpose followed by a tight per-argument list with no filler. The example path is the only slightly verbose element, but it usefully illustrates the expected relative-path form.

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 seven-parameter, unannotated, mutation-capable escape hatch, the description covers purpose, guardrails, confirmation requirement, and every parameter's meaning; return values need not be described because an output schema exists. An agent has enough to invoke it safely without guessing.

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 0%, so the description must compensate entirely, and it does: all seven parameters are explained, including the mutual-exclusivity of `path` and `key` ('used instead of `path`'), the placeholder semantics of `params`, and the conditional default for `method`. This is meaning well beyond the bare JSON types in 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: 'Call any gateway route directly', with the parenthetical '(advanced escape hatch)' signalling it is the generic fallback rather than a targeted endpoint wrapper. An agent can distinguish it from catalogue-driven siblings like weekend_promotions or search_products, though it never names a specific sibling it supersedes.

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 'advanced escape hatch' framing and the instruction that `key` comes 'from migros_endpoints()' give clear context for when this tool is appropriate. It also implies two operating modes (catalogue key vs raw path) but does not explicitly say to prefer dedicated tools first or warn against using it for routine reads.

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 supplied, the description carries the full disclosure burden. "Report" implies a read-only probe, but the description does not state whether it requires an authenticated session, whether it makes live network calls that could fail or be slow, or what the resulting state values mean. The presence of an output schema covers return shape but not 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 with no filler, front-loaded with the verb and the enumerated subjects. It is efficient, though the enumeration is a bare list that leaves key nouns unexplained.

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?

Complexity is low (no parameters) and an output schema exists, which lowers the bar considerably. Still, for a diagnostic tool in a ~90-tool sibling set, the description never says what question this tool answers or when to reach for it, leaving the agent without enough to select it reliably.

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 document and the baseline of 4 applies. Nothing in the description conflicts with the empty schema.

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