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

With no annotations, the description carries the full burden and delivers: it reveals that Ozon only draws from favorites and silently drops invalid items, plus instructs checking the returned items count. This goes well beyond the schema and is critical for correct invocation.

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 dense sentences: the first states the core function with an important nuance, the second provides a critical prerequisite and a practical check. No filler or redundancy; every word earns its place.

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

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

The description covers the gating condition (writes_enabled), the prerequisite (favorites), the mutation semantics (keep existing items), the silent-drop risk, and the follow-up action (check items count). With an output schema present, no return format details are needed; this is complete for the tool's 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 100% and both parameters (skus and uuid) are already documented clearly in the input schema, including the uuid's origin from list_selections()[].uuid. The description adds no further parameter-level detail, which is acceptable at baseline.

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

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

The description clearly states the action: 'Add products to a «Подборка»' with the specific nuance 'keeping what is already in it', which distinguishes it from sibling tools like set_selection_items or remove_from_selection. The resource and scope are 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 description provides explicit conditional context: products must be in favorites first, and it warns about silent drops. It implies incremental addition (vs replacing) but does not name alternative tools or explicitly state when not to use it, so it lacks full exclusion guidance.

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 fully discloses behavioral traits: default return-to-cart behavior, item-by-item cancellation possible, mismatch refusal due to non-undoability, reason_id defaults, and the possibility of a retention offer requiring the agent to check the `cancelled` field. These are significant beyond any schema info.

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 concise yet dense, with each sentence serving a purpose. It front-loads the core action and default behavior, then layers optional parameters and edge-case handling. No redundant words; the structure logically flows from what the tool does to how to use the parameters and what to check in the response.

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

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

Given the complexity of cancellation (partial vs whole, reason validation, non-undoable mismatch, retention offers), the description covers all critical aspects. The output schema exists, so return structure is not needed in the description, but the description still points out the `cancelled` and `detail` fields, which is essential for correct handling. Complete for an agent to invoke correctly.

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

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

Schema coverage is 100% and parameters are well documented in the schema. The description adds practical semantics: explains the neutral default '504', that '508' requires a comment, and that skus selection is validated against Ozon reports. This goes beyond the schema's basic descriptions, providing extra decision guidance for the agent.

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

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

The description clearly states the tool cancels an order and by default returns items to the cart. It differentiates from sibling tools by specifying partial cancellation via skus and the overall order-level action. The verb 'Cancel' and resource 'order' are explicit, and the behavior is distinct from cart/list management siblings.

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

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

The description gives clear context for when to use the tool (cancelling an order or specific lines) and references list_cancel_reasons as the source for reason_id. It implies the cancellation flow but does not explicitly state when not to use it or name alternative tools for order modifications. Still, the usage is well implied and actionable.

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 discloses the stateful side effect of recording prices and the fact that results depend on prior calls. It does not mention any further side effects (e.g., network calls or modifying favorites), but the disclosed behavior is clear and non-contradictory.

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 with no waste. The primary action and output format are front-loaded, followed by the essential usage caveat. 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?

For a parameterless tool with an output schema, the description provides everything needed: the action, the return structure, and the statefulness caveat. An agent can invoke it correctly without further clarification.

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 the baseline is 4. The description adds no parameter-specific detail because none exist; the schema already covers the empty property set.

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

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

The description uses a specific verb 'Record' and resource 'favorites prices', and clearly states the output diff with fields {drops, rises, added, removed}. This distinguishes it from siblings like list_favorites (listing) and set_favorite (modifying), leaving no ambiguity about its function.

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 explicitly advises 'Call it periodically' and explains the consequence: 'the comparison is only as old as the previous call.' This gives clear when-to-use guidance, though it does not mention alternatives or when not to use it, which are not necessary given the unique role among 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 full burden, and it delivers: it discloses validation behavior (refusal with list), the order of application, and a side-effect (points can withdraw pay-on-delivery). This is rich behavioral context beyond what any annotation would provide.

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 dense but each sentence earns its place: purpose, prerequisite, error behavior, ordering, and a warning. It is front-loaded with the core purpose. Slightly longer than minimal, but no wasted words.

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

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

For a mutation tool with 5 parameters, it covers prerequisites, error handling, application order, and a side-effect warning. An output schema exists, so return format is covered. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter dependency (points affecting pay-on-delivery) and the 'omit to leave unchanged' semantics, which are not captured in the individual schema descriptions. This adds meaningful value beyond the schema.

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

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

The description states a specific verb ('Set'), a resource ('checkout options'), and the key behavior ('return the recomputed order'), and it distinguishes itself from siblings like get_checkout and place_order. It clearly communicates the scope in the first sentence.

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 explicitly instructs the agent to read get_checkout() first and warns that invalid values are refused, which is a strong usage directive. It implies the alternative (use get_checkout for reading) but does not name it explicitly, so it falls just short of a 5.

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 discloses the gating condition, the empty-name refusal behavior, the account-level limitation to wishlists, and the return of a list_id. The presence of an output schema reduces the need to describe the full response shape.

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 concise sentences front-load the gating condition and core purpose, then add only high-value constraints and routing context. Every sentence earns its place with no filler.

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

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

Given one required parameter, an output schema, and a clear action, the description covers the gating prerequisite, the error condition, the resource type restriction, and the natural next step. Nothing essential is missing for an agent to invoke this correctly.

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

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

Schema coverage is 100%, and the schema already explains that name is the wishlist name as the user would read it. The description adds the Ozon empty-name rejection and ties the result to set_list_membership(), but it does not add substantial new parameter semantics beyond the schema.

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

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

The description uses a specific verb and resource: 'Create an empty wishlist' and explicitly says it returns the list_id. It also distinguishes itself from related concepts by stating that «Подборки» are not made this way, which disambiguates it from selection-creation siblings.

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 provides clear context: it is gated by writes_enabled, creates only wishlists, and is a precursor to set_list_membership(). It also warns that selections are not created through this tool, though it does not explicitly name an alternative sibling like create_selection.

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

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

With no annotations provided, the description carries the full burden. It discloses the write gating (writes_enabled), the side effect of public publishing to the account owner's profile, and advises asking before setting public=true. It omits error conditions but covers key behavioral aspects.

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 with zero fluff, front-loading the gating requirement and core action. The alternative tool is mentioned succinctly, and the public warning is placed at the end where it's most relevant.

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 output schema covers return values, so the description needn't detail them. It explains the creation scope and how to extend a selection, which is sufficient for an agent to call it correctly. A minor gap is the lack of mention of naming constraints, but those are in the schema.

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

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

Schema coverage is 100%, so all four parameters already have detailed descriptions. The description adds context about sku being for a single product and public's default, but doesn't introduce new meaning beyond the schema's own 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 states a specific verb (Create), a clear resource («Подборка»/selection), and its scope (around one product, returns uuid). It also distinguishes from add_to_selection, which handles adding more products, making it easy for an agent to tell them apart without opening the schema.

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

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

It explicitly directs the agent to use add_to_selection for adding more products, and warns about the public default requiring user consent. While it doesn't enumerate all alternatives, the guidance is clear and actionable for the primary use case.

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 burden of behavioral disclosure. It clearly states the operation is gated by writes_enabled, explains that products are not deleted, and explicitly warns that deletion is irreversible. This is strong transparency for a destructive 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?

The description is concise and front-loaded, starting with the gating condition and the primary action. Every sentence adds meaningful information: what is deleted, what is not deleted, irreversibility, and the need for user confirmation. No filler 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?

For a simple one-parameter destructive tool with an output schema, the description is complete. It covers the gating constraint, the exact scope of deletion, the non-undoable nature, and the required user confirmation. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, and the list_id parameter already has a clear description: 'The list to delete, from get_lists()[].list_id.' The tool description adds no additional parameter semantics beyond naming the resource as a wishlist, so the baseline score of 3 is appropriate.

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

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

The description opens with a clear verb and resource: 'Delete a wishlist.' It also differentiates from the sibling delete_selection by naming the resource type (wishlist/list vs selection), so an agent can select the correct tool without 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 description provides practical guidance by warning that the operation is not undoable and that the user should confirm first, but it does not explicitly state when to prefer this tool over alternatives or mention any when-not-to-use conditions. Usage is implied rather than fully specified.

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

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

No annotations are provided, so the description carries the full burden, and it succeeds. It discloses that the operation deletes the selection, does not delete its products, is irreversible per Ozon, and requires user confirmation — strong transparency for a destructive operation.

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

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

Every sentence earns its place: the gating note, the action, the side effect, the irreversibility warning, and the confirmation requirement. It is front-loaded and compact without filler.

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

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

For a single-parameter destructive tool with an output schema, the description covers the action, side effects, irreversibility, and confirmation step. The only real gap is the absence of explicit routing against sibling deletion tools, but the rest of the context is sufficient.

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

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

The schema already covers the single uuid parameter 100% by explaining it comes from list_selections()[].uuid, so the baseline of 3 applies. The description itself adds no parameter-specific detail, but none is needed here.

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 'Delete a «Подборка»' — a specific verb and resource — and immediately clarifies the scope: the products inside are not deleted. This distinguishes it from sibling deletion tools like delete_list and makes the tool's purpose 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 provides useful context by noting the operation is gated by writes_enabled and that the user must confirm first because deletion is irreversible. However, it does not explicitly compare this tool with siblings such as delete_list or set_selection_items, so an agent must infer when this is the correct choice among 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?

With no annotations provided, the description carries the behavioral disclosure burden. It discloses an important nuance: the date is relative to the address, so both must be quoted together. It also clarifies the estimate is pre-order and per product. It does not explicitly state it is read-only, but 'estimate before ordering' strongly implies no mutation.

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

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

The description is compact and every sentence adds value: the core output, the address-relative date caveat, and the sibling routing. The first clause is a slightly awkward fragment ('When a product would arrive...') rather than a clean verb phrase, which costs a point but does not harm clarity.

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 tool with an output schema, the description provides the necessary context: what is estimated, the per-address date behavior, the pre-order scope, and which sibling tools cover adjacent cases. An agent has enough information to select and invoke the tool correctly.

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

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

Schema coverage is 100%, and the parameter description already explains that sku_or_url accepts a SKU or full product URL and that variants have their own SKUs. The tool description adds context that the estimate is per product, but it does not add significant parameter-level meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly defines what the tool provides: a delivery estimate for a product before ordering, including arrival date, target address, and source warehouse. It also distinguishes itself from list_orders() and get_checkout() by explicitly scoping it to per-product pre-order estimates, so an agent can tell it apart from siblings.

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 states exactly when to use this tool: per product, before ordering. It also names the alternatives for related scenarios, saying existing order dates are in list_orders() and checkout-formation dates are in get_checkout(), giving the agent clear routing guidance.

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 discloses a gating condition (writes_enabled) and the behavioral trait that visibility is preserved, which are both valuable beyond the schema. It does not describe return values or error conditions, but an output schema 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?

The description is concise, with a single purpose statement and a key behavioral note. The gating condition is front-loaded, making it immediately actionable, and there is no fluff.

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

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

Given the tool's simplicity, the description covers the core purpose, the gating condition, and the visibility preservation. The schema covers parameters, and an output schema exists, so return values are not needed. It is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the description adds little beyond what the schema already documents. The description's mention of 'rename' and 'replace description' aligns with the schema but does not provide new parameter-specific details.

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

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

The description clearly states the tool's action: rename a selection and optionally replace its description. It distinguishes from siblings like create_selection, delete_selection, and set_selection_public by specifying exactly what it modifies.

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 provides clear context on what the tool does and notes that visibility is preserved, implying that visibility changes belong elsewhere. However, it does not explicitly name alternative tools or state when not to use it, leaving some inference to the agent.

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 full responsibility for behavioral disclosure. It clearly explains ranking by payable price, the two lookup sources, the caveat that offer entries have no title and need confirmation, and the important failure behavior of raising instead of falsely reporting nothing cheaper.

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 compact and front-loaded with the core behavior, followed by source detail, a caveat, and the failure mode. Every sentence adds meaningful operational information without wasted words.

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

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

Given an output schema exists, the description covers the non-obvious behavioral and data-quality aspects: ranking, limit, source logic, missing titles on offers, and exception behavior. It is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds useful context beyond the schema by explaining that sku_or_url drives both the exact product offers and a title-based search, and by restating the limit default in the operational context of ranking output.

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: it finds the cheapest lots of the same product ranked by payable price. It also distinguishes itself from generic search by explaining its two sources and the exact-product focus.

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

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

The description gives clear context for when the tool is appropriate: when finding cheaper copies of the same product, using both Ozon's offers list and title-based search. It does not explicitly name alternative sibling tools or state when not to use it, but it does provide a useful follow-up instruction to verify offers with product_details() before quoting them.

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

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

No annotations are provided, so the description carries the full burden. It does disclose meaningful behavior: pagination ('paginated through') and the semantic role of the `checked` field ('the tick is what decides the order's contents'). It omits auth requirements, rate limits, and empty-cart behavior, which are gaps for a zero-annotation tool, but the disclosed traits are genuinely useful.

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 dense but not wasteful; the core scope ('The whole cart') is front-loaded, and the details on item fields, `checked` semantics, and group headings each earn their place. Slightly long due to parenthetical group-heading examples, but efficient overall.

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 and zero parameters, the description covers the key aspects an agent needs: scope, pagination, item composition, the decisive `checked` field, and group headings. Minor omissions (empty-cart behavior, auth) are not critical given the output schema carries return-structure details.

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 0 parameters, so the baseline of 4 applies. There is nothing for the description to document beyond what the empty schema already conveys, and it adds no misleading parameter information.

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 (the cart) and scope ('The whole cart... paginated through'), with specific detail on contents: items with title, price, quantity, and `checked`, plus group headings. The verb is implicit but unambiguous. It does not explicitly name a sibling to differentiate from, but the read-vs-mutate contrast with set_cart_quantity and select_cart_items is evident.

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

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

Usage context is implied rather than stated — 'the whole cart' signals a full-read operation, and the read nature contrasts with mutation siblings. However, there is no explicit guidance on when to use this versus alternatives, no exclusions, and no note about prerequisites like being logged in.

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 full behavioral disclosure. It reveals a side effect ('Forms the checkout itself if Ozon has not yet'), explains the available=false reason mechanism, details the shipment_items loading default, and describes nuanced pay-on-delivery scope behavior. This is unusually transparent.

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 long and dense, but nearly every sentence contributes distinct information about checkout structure, behavior, or default values. It is not front-loaded with a clear verb phrase, but it is well organized and avoids redundancy.

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

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

Given the output schema exists, the description appropriately focuses on behavioral semantics and edge cases rather than return fields. It covers the tool's side effect, failure reasons, parameter defaults, and relationship to sibling tools, making it complete for an agent deciding to call or interpret this 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 single parameter shipment_items has full schema description coverage, so the baseline is 3. The description adds context by tying the default loading behavior to pay_after_receipt.scope being 'partial' and explaining that shipment_items forces loading on or off. This enriches the parameter's meaning beyond the schema alone.

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 precisely defines what get_checkout returns: the current checkout being formed from selected cart items, including payment methods, deliveries, shipments, and totals. It also distinguishes the tool from its direct siblings by stating that configure_checkout changes the checkout and place_order submits 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 description provides clear context: it operates on selected cart items, can create the checkout if Ozon has not yet, and reports available=false with a reason when something needs fixing. It names the alternatives configure_checkout and place_order, but does not explicitly state scenarios where get_checkout should be avoided in favor of get_cart or other 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 provided, the description carries the full burden of behavioral disclosure. It only states the output content (description text and images) but does not explicitly mention side effects, read-only status, authentication needs, or any limitations. The 'get' prefix implies read-only behavior, but the description itself does not confirm it.

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 concise, containing a single short phrase with no redundant words. It is appropriately sized for a simple retrieval tool and immediately communicates the core purpose.

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 tool with one parameter and an output schema, so the short description is partly acceptable. However, it lacks any context on when to prefer this tool over related product-data tools, and it does not mention that it accepts both SKU and URL (though the schema covers that). Overall, it is adequate but has clear gaps in usage context.

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 fully describes the single parameter sku_or_url with 100% coverage, including examples and clarification that variants have own SKUs. The description adds no additional parameter semantics, so the baseline score of 3 applies.

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

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

The description, "Product description text plus the images embedded in it," clearly identifies what the tool returns: the product description and its embedded images. It is distinct from siblings like product_details or get_reviews by focusing specifically on the description content, but it lacks an explicit verb such as 'retrieves' or 'returns', so it is more of a noun phrase than a full command.

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 provides no guidance on when to use this tool versus alternatives like product_details or search. There is no mention of exclusion conditions, prerequisites, or the specific scenario where this tool is the correct choice, leaving the agent to infer usage solely from the name.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds the meaningful fact that the returned balance is what card payments draw on and drives pay_order top-up decisions, but it does not explicitly state read-only status, auth requirements, or failure behavior. For a zero-parameter balance query, this is reasonable but not fully 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?

Three short sentences each earn their place: the first states the data returned, the second explains its operational meaning for pay_order, and the third routes to get_points for detail. There is no filler or redundancy.

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 operation with an output schema, the description covers what is returned, why it matters in the payment flow, and how to get more detail via get_points. Nothing required to call the tool correctly is missing.

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

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

The input schema has zero parameters, so there is no parameter-semantics burden for the description to carry. Per the zero-parameter baseline, this dimension should score 4; no additional parameter documentation 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 clearly identifies the resource as the Ozon Card balance and total points, and differentiates it from get_points by pointing to that sibling for point-type breakdown. However, it lacks an explicit action verb and relies on the tool name's 'get' to convey 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?

The description explicitly routes point-type breakdowns to get_points() and explains that the balance determines whether pay_order() needs a top-up. This gives an agent clear context for when this tool matters and which sibling covers the alternative case.

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 discloses that lists are account-scoped, the response includes size/list_id, the sku parameter changes each list to include contains, and that «Подборки» are intentionally not exposed. This is solid transparency for a simple read operation.

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

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

Three dense sentences with no filler. The core purpose is front-loaded, the cross-reference to consuming functions is relevant, and the «Подборки» clarification earns its place.

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

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

The tool has one optional parameter, low complexity, and an output schema, so the description doesn't need to enumerate return fields. It provides the essential integration context and edge semantics for the sku parameter, making it complete for an agent to call correctly.

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

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

The input schema already documents sku at 100% coverage. The description adds value by explaining the purpose: sku enriches each list with contains so callers can avoid duplicating a product in a list.

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 specifies the resource ('account's wishlists'), the returned fields (size, list_id, conditional contains), and explicitly distinguishes wishlists from Ozon's «Подборки». This differentiates it from related list-like sibling tools.

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 explains that list_id feeds set_list_membership() and delete_list(), and that passing a sku lets callers check contains to avoid double-adding a product. It also rules out «Подборки», though it doesn't directly compare against sibling tools like list_favorites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the returned content but does not state that the operation is read-only, whether authentication is required, or any other behavioral traits. The tool name implies a getter, but the description itself does not clarify side effects or safety.

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 free of filler, front-loading the resource type and enumerating the returned categories. It is slightly fragmentary rather than a full sentence, but every phrase adds useful 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?

Given the low complexity of a zero-parameter read tool and the presence of an output schema, the description is largely complete for invoking the tool. It lists the main content areas, though it omits any usage context or explicit read-only statement, which are not critical for a simple getter.

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 and 100% schema coverage, so there are no parameter semantics to clarify. The description does not need to compensate for missing schema information, and the baseline for zero-parameter tools 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 clearly identifies the resource (points) and the specific data returned: points by type with amounts, burning points, and per-store seller bonuses. It is not a tautology and is distinguishable from siblings like get_cart or get_finances, though it does not explicitly name an 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?

There is no guidance about when to use this tool versus alternatives such as get_finances, purchases, or list_orders. The description only states what data is returned, leaving the agent to infer the appropriate context.

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 disclosure burden. It lists the data returned, but does not disclose pagination, ordering, behavior for products without reviews, authentication requirements, or side effects. The read-only nature is only implied by the name and content, not stated.

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 very short and scannable, front-loading the core resource and then enumerating the included data. It is a fragment rather than a complete sentence, but every phrase earns its place with no redundant wording.

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

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

For a simple one-parameter read operation with a fully described schema and an output schema, the essential content is covered. Missing are practical details like pagination or limits for large review sets, and a clearer relationship to sibling tools such as product_details, making it adequate but not fully 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?

The schema already documents the single parameter thoroughly, including accepted formats (SKU or full ozon.ru URL) and the variant-SKU note. With 100% schema description coverage, the description adds no extra parameter detail, so the baseline of 3 is appropriate.

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

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

The description identifies the resource ('Reviews on their own') and enumerates the contents returned: overall score, individual reviews with author/score/text/date, and review photos. It lacks an explicit imperative verb, but combined with the tool name and content list, the purpose is clear and distinct from broader product tools.

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

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

There is no explicit guidance about when to use this tool versus alternatives like product_details or search. The phrase 'on their own' weakly implies standalone review retrieval, but no alternatives, exclusions, or selection conditions are stated, leaving usage to inference.

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

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

No annotations are provided, so the description carries the disclosure burden. It explains the returned faceted structure and how to use values (option.value vs range 'min;max'), which is meaningful behavioral context. Lacks only details about failures or empty results, but the core behavior is well covered.

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

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

Three sentences deliver a precise structure definition, usage example, and workflow. All sentences are high-value with no redundant filler; the format example is compact and 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?

Given the tool's simplicity (one parameter), the presence of an output schema, and the detailed usage flow, the description is complete. Agents know what to send and how to interpret results, including value formats.

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

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

Schema coverage is 100% for the query parameter, and the description reinforces that it must be the same search text used previously. This adds practical context beyond the schema's description, ensuring agents pass the correct value.

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

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

The description clearly states the tool returns facets available for a query, with structure {name, key, type, options|range}. It distinguishes itself from sibling tools like search by explaining it provides filter metadata, not search results.

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

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

Explicitly describes the flow: search → get_search_filters → search(filters), and explains how to apply returned filters with the search tool. This gives the agent clear when-to-use and integration guidance beyond mere existence.

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 burden of behavioral disclosure. It reveals that the tool returns a full selection object and explains a nuance about visibility reliability ('a selection under review is listed as На модерации either way'). While it doesn't explicitly state it's read-only, the description clearly implies a non-mutating retrieval, and the added moderation context adds useful behavioral insight beyond a common get. It would be improved by an explicit statement that it performs no side effects.

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 sentences, front-loaded with the core purpose. It efficiently contrasts with the sibling tool and explains why this tool is necessary. The moderation explanation adds a slightly tangential detail but supports the usage guidance, so it earns its place. Not perfectly minimal but well structured.

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

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

Given the tool's low complexity (1 parameter) and the presence of an output schema, the description provides enough context for an agent to use it correctly. It explains what the result contains, why it differs from list_selections, and the reliability caveat about visibility. Error handling or invalid uuid cases are not mentioned, but for a simple getter this is acceptable. The description covers the essential contextual information.

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 coverage is 100% — the uuid parameter is fully described as 'The selection, from list_selections()[].uuid.' The description does not add additional parameter semantics beyond what the schema already provides. The contrast with list_selections is about the return value, not the parameter, so it doesn't enhance parameter understanding. Baseline 3 applies.

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

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

The description specifies exactly what the tool returns — a full selection with name, description, product count, status, and public visibility. It also distinguishes itself from list_selections by explicitly stating what list_selections lacks. The verb and resource are clear, and the tool is clearly differentiated from its sibling tools.

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 explicitly states when to use this tool over list_selections: when you need the description or the `public` flag. It also explains why this is the only reliable read of visibility, given the moderation ambiguity. This provides clear contextual guidance.

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 behavioral disclosure burden. It exposes a non-obvious constraint: the catch-all reason with needs_comment=true is refused without a comment. It also notes that reason_id is returned, which is essential for a subsequent cancel_order call.

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

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

The description is only two sentences, with the main purpose front-loaded and a caveat appended. Every word contributes meaning; there is no redundant or filler content.

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

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

The output schema and parameter schema cover return structure and input format. The description adds purpose and a key behavioral caveat. The only minor omission is an explicit connection to the cancel_order workflow, but that is easily inferred from the sibling list.

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

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

Schema coverage is 100%, and the parameter schema already explains the order number format and that detail_link is accepted. The description adds no parameter-level information, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool's resource ('Reasons Ozon will accept for cancelling an order') and the key output ('reason_id'). It distinguishes the listing intent from the sibling cancel_order, which actually performs the cancellation.

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 when preparing to cancel an order, but it does not explicitly state 'use before cancel_order' or mention any exclusions. The relationship to cancel_order is inferable from sibling names rather than stated in the description 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 must carry the behavioral burden. It discloses that pagination is automatic, that `limit` caps results, and that there is no page parameter to request. It also enumerates the returned fields. It does not mention authorization or side effects, but listing favorites is inherently read-only and safe. This is solid disclosure beyond the schema.

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

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

The description is two sentences with zero redundancy. The purpose is front-loaded, the return fields are listed compactly, and the pagination behavior is explained efficiently. 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?

Given the tool's simplicity, the presence of an output schema (even though not shown) and the description's inclusion of return fields and pagination, it is largely complete. It does not cover error cases or ordering, but those are minor for a basic list operation. It could benefit from stating it returns the current user's favorites, but that is strongly implied by the name and sibling context.

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

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

The schema already fully documents the `limit` parameter (coverage 100%), so the baseline is 3. The description adds valuable context by clarifying that pagination is handled automatically and there is no separate page parameter. This extra information helps the agent understand the single parameter's role beyond the schema's basic description.

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 the exact purpose: listing favorites as product tiles, with the specific fields (sku, title, price, old price, url). This clearly distinguishes it from sibling tools like get_lists (which handles user lists) and set_favorite (which toggles favorites). The verb and resource are explicit.

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 (to view a user's favorite products) but does not explicitly contrast with alternatives like get_lists or set_favorite. It provides clear context on the return type, which helps an agent infer when to call it, but it stops short of stating when not to use it or naming a specific sibling.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals non-obvious facts: there is no order total; amount_due_at_pickup is per entry; paid null means unknown, not unpaid; each entry is a delivery group that can contain multiple order_numbers; and giving a date searches the archive and stops paginating. This goes far beyond a generic list description.

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 dense but each sentence carries a distinct, useful fact: output composition, monetary semantics, delivery-group modeling, archive/date behavior, and downstream routing. It is longer than strictly necessary but not padded; the 'cheaper' explanation is slightly extra but still relevant to usage.

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

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

For a list operation with four parameters and no annotations, the description covers output structure, tricky field semantics, grouping behavior, archive/date behavior, and how to connect to related tools. The only minor gaps are date inclusivity and authentication requirements, but the output schema exists and shared login context is implied by the sibling 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?

Schema coverage is 50%, with limit and scope documented but date parameters only minimally. The description adds meaningful date behavior ('Giving either date searches the archive and stops paginating once past the window') and clarifies output semantics tied to price/paid. It does not elaborate on limit, but the schema already documents that parameter, so the description compensates reasonably 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 specifies the resource (orders) and the returned fields (status, state, pickup point, delivery slot/ETA, items), and clearly flags the absence of an order total. It lacks an explicit imperative verb like 'lists', but the tool name and content make the purpose unmistakable, and it distinguishes itself from downstream tools like order_products(), cancel_order(), and pay_order().

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

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

It gives concrete follow-up guidance: 'Pass an entry's order number or detail_link on to order_products(), cancel_order() or pay_order().' It also explains when date parameters trigger archive search and stop pagination, which helps an agent choose efficient usage. It does not explicitly state when not to use this tool versus a sibling, so it falls short of a full 5.

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 discloses sorting order ('newest first'), exact fields returned, and pagination behavior via 'limit'. This goes beyond a minimal listing and gives the agent a good sense of what to expect, though it does not explicitly state side-effect-free or authentication requirements.

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 concise sentences: the first enumerates all returned fields, the second explains the pagination. No fluff, high information density, and important details are front-loaded.

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

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

Given the simple schema (only one optional parameter) and the presence of an output schema, the description covers the essential invocation details: scope, ordering, fields, and pagination. It lacks explicit mention of error cases or authorization, but that is acceptable for such a straightforward list operation.

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, limit, is fully described in the schema ('How many entries to return at most'). The description adds meaning by explaining pagination ('Paginated through – `limit` caps how many come back'), which is not redundant with the schema description, so it earns above the baseline.

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

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

The description clearly states the action ('Returns...') and the resource ('this account has opened'), with specific details about the content (return number, date, status badge, amount, products). It is unambiguous and distinct from sibling tools like list_orders, which cover orders rather than returns.

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 explicit guidance on when to use this tool versus alternatives. The description implies it is for listing returns, but does not mention scenarios where another sibling (e.g., list_orders or get_finances) might be preferred, nor any preconditions or context.

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 disclosure burden. It discloses the scope (account-level), the fact these are curated publishable lists rather than wishlists, and the meaning of status values including private/public/moderation states. It does not explicitly state read-only behavior or pagination, but the list semantics and output-focused detail cover the important 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?

The description is compact: one sentence defines and differentiates the resource, a second explains the fields an agent can expect. Every clause earns its place and the most important distinguishing fact (not wishlists) is front-loaded.

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

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

For a zero-parameter listing tool with an output schema, the description is nearly complete: it states the scope, return fields, and status semantics, and links the returned UUIDs to the selection-tool family. It could add an explicit note about what it does not return (e.g., full product data) or authentication requirements, but those gaps are minor.

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 are no parameters, so schema coverage is trivially 100% and no parameter documentation is needed. The description adds useful return-value semantics (uuid, product count, Ozon status) even though that is output rather than parameter info, fully compensating.

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 ('account's curated, publishable lists of products') and immediately distinguishes it from wishlists in get_lists(), which is enough to know what it operates on. It stops short of an explicit verb like 'Returns' or 'Lists', so the action is inferred from the tool name 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?

It tells the agent this is not the wishlist tool (get_lists) and explains that the returned UUIDs are what 'every other selection tool takes', implying list_selections is the entry point for selection operations. It lacks an explicit 'use this when... / use get_lists when...' rule but the context is clear.

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 behavioral traits. It states the output fields and input formats but does not explicitly indicate that this is a read-only operation, any authentication requirements, error handling, or potential limitations. The absence of any mention of side effects or edge cases leaves an agent without full understanding of its 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?

The description is two sentences: the first lists output fields, the second explains input formats. It is front-loaded with the purpose and extremely efficient, containing no redundant words. Every clause earns its place, making it an excellent example of concise, structured writing.

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

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

Given the tool has a single simple parameter, an output schema, and no nested objects, the description covers the core purpose and input requirements well. It does not discuss error cases or prerequisites like authentication, but the presence of an output schema alleviates the need to detail return values. Overall, it is nearly complete for a simple read operation.

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

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

Schema description coverage is 100% and the schema already explains the parameter format including the detail_link acceptance. The description adds a concrete example and reinforces the dual format, but it does not provide substantive new meaning beyond the schema. Since the schema fully documents the parameter, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns items of one order with a specific list of fields (sku, title, price, variant, seller, link). It distinguishes itself from list_orders (which lists orders, not items) and other product-related tools by focusing on a single order's contents. The verb 'Items of one order' is specific, though it doesn't explicitly name a sibling to avoid confusion, which keeps it slightly below a 5.

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

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

The description specifies accepted input formats (order number or detail_link from list_orders) and implies it should be used when needing the items of a particular order. However, it does not explicitly state when NOT to use it or mention alternative tools for other scenarios. The guidance is clear enough for basic use but lacks explicit exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It discloses a critical limitation: 'this server never finishes the charge itself' — the payment must be completed by the user at payment_url, which signs into Ozon Bank. It also explains the result fields (amount_due, shortfall, next_step) and instructs how to relay them. This goes beyond basic behavior to reveal side effects and user involvement.

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 longer than average but every sentence contributes: it states purpose, explains result fields, clarifies the server's role, and gives user instructions. The purpose is front-loaded in the first sentence. It is structured but slightly verbose; could be tightened while retaining all details.

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

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

For a payment-charge tool with an output schema, the description covers the preconditions (order awaiting payment), the action, the result fields, and the user's next steps. It also mentions the pay-on-delivery alternative. It does not explicitly cover error handling (e.g., what if the order is already paid), but the precondition is stated. Given complexity, this is fairly complete.

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

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

Schema coverage is 100%, and the schema description already documents the order parameter including format and accepted detail_link. The tool description does not add any additional meaning beyond what the schema provides. Baseline of 3 is appropriate because the schema fully handles parameter semantics.

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 action: 'Ask Ozon to charge an order left in «Ожидаем оплаты»' and 'report what the user must still do.' It clearly distinguishes from siblings like place_order (new orders) and cancel_order (cancellations) by targeting the awaiting-payment state. The verb 'charge' plus resource 'order' is precise.

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 explicitly states the condition for use: orders in the 'Ожидаем оплаты' state. It also hints at an alternative: 'Ordering with pay-on-delivery avoids all of it,' implying when not to use this tool. However, it does not name a specific sibling tool as an alternative, leaving some inference to the agent. This is clear context but not fully explicit about exclusions beyond pay-on-delivery.

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 full behavioral burden. It discloses that the tool 'SPENDS REAL MONEY', is gated by 'orders_enabled', is not undoable except via cancel_order(), refuses the call if the total mismatches, and returns only when the order actually exists. It also explains payment settlement behavior for Ozon Card and pay-on-delivery. This is exemplary transparency.

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 relatively long but every sentence adds critical operational detail for a high-risk action. The gating warning is front-loaded, and instructions are sequenced logically. Minor redundancy exists ('pass back the figure they agreed to' vs. 'confirm_total' semantics) but overall it is well-structured.

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 financial transaction tool, the description covers preconditions, required user-facing steps, failure conditions, return value (order_number), and downstream tool dependencies. Even with an output schema present, the description explains what an agent needs to know to call it correctly and safely. Nothing essential is missing.

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

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

The schema already fully describes confirm_total with examples and validation semantics (100% coverage). The description reinforces this by instructing to copy from get_checkout().totals and explaining the refusal on mismatch. It adds value by tying the parameter to the workflow, though the schema is already strong.

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

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

The description clearly states the action: 'Submit the order that get_checkout() describes.' It uses a specific verb and resource, and distinguishes itself from related tools like get_checkout (which only describes) and cancel_order/pay_order (which are post-submission steps).

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?

Explicit usage guidance is provided: read get_checkout() immediately before, show the user the total, and pass back the agreed figure. It also mentions the refusal condition if the total no longer matches, and directs the caller to use cancel_order() or pay_order() subsequently. This is clear when-to-use and how-to-use context.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it defines the three price meanings, explains available, and reveals the critical variant SKU behavior—that the variant SKU is what goes into the cart and for apparel is the only addable one. This is substantive context beyond what the schema or tool name conveys.

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

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

The description is front-loaded with the one-line product card summary, then organized into pricing, availability, cheaper offers, variant behavior, and optional-flag guidance. Every sentence adds operational value; the length is justified by dense, necessary semantics 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?

For a 3-parameter read tool with full schema coverage and an output schema, the description covers the runtime facts an agent needs: price interpretation, variant SKU handling, optional fetches, and sibling alternatives. Auth and rate limits are not needed for this get-details tool's core contract.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics: variants carry their own sku and 'that sku is what goes into the cart', and with_description/with_reviews are separate requests with standalone alternatives. This goes beyond the schema's brief parameter descriptions, particularly for sku_or_url.

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 precise product-card scope: title, three prices, variants, characteristics, gallery photos. It names sibling tools like get_description(), get_reviews(), and find_cheaper() so an agent can distinguish this tool from related ones without opening their schemas.

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 explicitly routes the agent to alternatives: get_description() and get_reviews() do the same fetches standalone, and find_cheaper() lists cheaper offers, implying when not to bundle those requests. It does not explicitly contrast product_details with search, but the scope of a full product card is clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses the search behavior (server-side query) and what is excluded (orders, statuses, totals), but does not mention whether the operation is read-only, potential permissions, rate limits, or error behavior. The description gives some useful behavioral context but has clear gaps.

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

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

The description is three sentences, each with a distinct purpose: define the tool, explain query behavior, and name the sibling alternative. There is no fluff or repetition, and the most important information is front-loaded.

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

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

Given the output schema exists, return values need no explanation. The description covers purpose, usage, behavior, and alternatives. It could add a note on whether the history is personal or requires authentication, but for a simple list tool the current level is sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra meaning for the query parameter by explaining that Ozon searches server-side and that this is cheaper than paging, which is not in the schema description. No extra context for sort or limit is needed since the schema already documents them.

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 ('bought'), resource ('everything ever bought'), and presentation format ('product tiles (sku/title/price/url)'). It also names the use cases ('have I bought this before', 'buy that thing again'), which clearly distinguishes it from siblings like list_orders.

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 explicitly says that orders, statuses, and totals are not here and points to list_orders() as the alternative. It also explains when to use the query parameter (server-side search is cheaper than paging), giving clear usage context and 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, the description carries the full burden and does well: it declares the mutation scope and explicitly describes failure behavior ('Fails if the selection holds none of them, rather than reporting a removal that did not happen'), which prevents false-success assumptions. It does not detail permissions or reversibility, but the writes_enabled gate is 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 tight sentences; the operation and scope come first, then the critical failure behavior. No filler and no repetition of schema content.

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

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

For a two-parameter mutation with full schema coverage, an output schema, and a clear SKU-source hint, the description covers the essential call context and failure mode. It could name sibling alternatives or clarify whether partial matches also fail, but the core information an agent needs is present.

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

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

Schema description coverage is 100%, so a baseline of 3 applies. The description adds value by tying skus to a presence requirement: removal fails if none of the provided SKUs are currently in the selection, which goes beyond the schema's enumeration of the parameters.

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 operation ('Take products out'), the target resource ('a «Подборка»/selection'), and clarifies the partial scope ('keeping the rest'). It is readily distinguishable from siblings such as add_to_selection, set_selection_items, and edit_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?

The intended usage is clear: use this to remove a defined set of SKUs from a selection while preserving the rest. However, it does not explicitly state when to prefer it over alternatives like set_selection_items or edit_selection, nor does it state 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 present, so the description carries the full burden. It discloses critical behaviors: limit is depth (pages walked), sort='cheap' ranks on payable price rather than Ozon's order, text search is literal about words (brand mismatch), and tile titles are seller wording that may omit the model. These are non-obvious behaviors the agent must know.

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 dense but every sentence contributes value. It front-loads the core purpose and then adds nuances in a logical order. While it is longer than typical, it is efficient because each clause covers a distinct behavioral point with no fluff. A 4 is fair because it could be tightened slightly without losing substance.

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 complex with filters, sort semantics, and interaction with sibling tools. The description covers all necessary operational details: how to combine query and category, how to use filters, how limit behaves, and when to defer to product_details(). An output schema exists, so return format is defined. Nothing essential is missing.

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

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

Even though schema coverage is 100%, the description adds substantial meaning beyond the schema: it explains the limit semantics (depth not page size), interprets sort values, details the filters format with a concrete example, and clarifies category slug usage. This is far above the baseline 3.

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

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

The description states a specific verb and resource: 'Storefront search → product tiles (sku/title/price/url)'. It clearly distinguishes the tool from siblings by noting that a tile is not a card and that product_details() is needed for deeper data. The 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?

Provides explicit when-to-use and when-not-to-use guidance. It directs agents to product_details() for variants/characteristics/photos/stock and to get_search_filters() for filters. It also explains that price narrowing is a filter, not a sort, and recommends searching the model rather than brand+model, with a concrete example. This fully routes the agent.

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

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

With no annotations, the description carries the burden of disclosing behavior. It explicitly notes the writes_enabled gate, states that the tool modifies which items are ticked, and explains the return value (the cart after ticking). It also clarifies the effect on get_checkout. This is a solid disclosure, though it does not mention reversibility or idempotency.

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 compact block of three sentences, each earning its place: the gate, the purpose/example, and the return behavior. It is slightly long but not wasteful, and front-loads the most critical information (the gate and the ordering dependency).

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

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

The description covers the essential context: the ordering flow, the dependency on get_checkout, and the return value. Given that an output schema exists (not shown here) and the input schema is fully descriptive, the description is complete enough for an agent to use the tool correctly. It does not over-explain.

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

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

The schema already describes both parameters in detail (100% coverage), but the description adds a practical example ('buy these two' -> mode='only' with two skus) that clarifies the semantics beyond the schema. This adds value without redundancy.

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 ('Choose') and resource ('cart items') and explains the tool's role as the step that composes a checkout. It clearly distinguishes this from read-only tools like get_cart and quantity-changing tools like set_cart_quantity, and ties it to the checkout flow.

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 explains when this tool is used ('the step that composes a checkout') and gives a concrete example of mode='only'. It implies that get_checkout depends on ticks, so this should be called before ordering. It does not explicitly name alternatives or state when not to use it, but the context is clear enough.

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 burden. It clearly indicates this is a read operation ('the read to make before changing'), implying no side effects. It also discloses what data is returned (sku, title, price, link) and contrasts with sibling reads. It doesn't explicitly state 'read-only', but the context strongly implies it, so a small deduction is appropriate.

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 with zero redundancy. The first sentence states the purpose and contents; the second provides the usage context and differentiation from siblings. Information is front-loaded and every word earns its place.

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

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

For a simple read operation with one parameter and an output schema (which carries return details), the description fully covers why and when to use it, what it returns, and how it differs from related tools. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%: the only parameter, uuid, is already documented in the schema as 'The selection, from list_selections()[].uuid.' The tool description adds no additional parameter detail beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb (holds) and resource (products of a selection), enumerates the fields returned (sku, title, price, card link), and explicitly distinguishes it from sibling tools list_selections() and get_selection() which only provide a count. An agent can immediately tell this is the detail read for a 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?

It explicitly states when to use this tool: before changing the contents of a selection. It names the alternatives (list_selections, get_selection) and explains why they are insufficient (only a count), leaving no ambiguity about the tool's role.

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 burden. It discloses critical behaviors: signed-out sessions cause other tools to raise (rather than silently return empty results), and backup_available=true may cause automatic recovery on the next call. It also notes that operator settings are immutable by any 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?

The description is compact and front-loaded with the most important instruction ('Start here'). Each sentence adds distinct value: purpose, flag semantics, error behavior, and recovery steps. No filler or redundancy.

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

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

Given the tool has an output schema (not shown but signaled) and zero input parameters, the description covers all necessary context: what the flags mean, what happens when signed out, and how to recover. It fully equips the agent to interpret results and take appropriate next actions.

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 the description correctly omits parameter details. The baseline for 0 params is 4, and nothing further is needed. The description instead focuses on output semantics, which is appropriate.

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

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

The description clearly states that the tool reports session status and server permissions, and it explains the two key flags (writes_enabled, orders_enabled) and their scope. It also positions itself as the entry point ('Start here'), which distinguishes it from all sibling tools that operate on specific resources.

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 explicitly says 'Start here', establishing it as the first tool to call. It also provides clear conditional guidance: when signed_in is false, other tools will raise, and recovery is start_login() + submit_login_code(). This gives the agent a decision path and 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 provided, so the description fully carries the behavioral burden. It discloses that Ozon reports no outcome, so the cart is read back, and explains the meaning of 'ok=false' with 'detail'. It also discloses the gating by writes_enabled and the edge case of out-of-stock or base SKU without size.

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

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

The description is dense but efficient; every sentence serves a purpose. It front-loads the core purpose, then explains the unified behavior, response semantics, and workflow caveats without redundancy.

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

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

Given the output schema exists, the description doesn't need to explain return structure, but it goes further to explain the ok=false semantics and the gating condition. It also covers the apparel edge case and the distinction from order selection, making it complete for correct 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 coverage is 100%, with clear descriptions for both sku and quantity. The description reinforces the quantity=0 removal behavior but does not add substantial parameter-specific meaning beyond the schema. The variant SKU note is already in the schema, so the description adds no extra parameter insight.

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 action ('Set how many of a product are in the cart') and clarifies that adding, changing, and removing are all handled by this single call. It distinguishes itself from siblings like get_cart (view) and select_cart_items (select for order) by defining its unique role in the cart workflow.

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

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

It explicitly says when to use it (to modify cart quantity), and clarifies the relationship with select_cart_items by noting that being in the cart is not being in the order and that select_cart_items should be called before checkout. It also guides on using the variant SKU for apparel, pointing to product_details() as the source.

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 full burden. It discloses that the tool is gated by 'writes_enabled', that Ozon reports no outcome, and that confirmation requires a separate read call. This goes beyond basic functionality and explains real-world 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?

The description is compact and front-loaded with the gating condition. Every sentence adds value: the action, the lack of direct outcome, the confirmation read, and the linkage to price-drop watching. No wasted words.

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

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

For a simple two-parameter write tool with an output schema, the description fully equips the agent to call and verify the operation. It covers what happens, how to confirm, and the relationship to other favorites-related 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 input schema provides 100% description coverage for both parameters ('add' and 'sku'), including examples and usage notes. The tool description adds no additional parameter-level detail, so baseline 3 is appropriate.

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

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

The description states a specific verb ('Add'/'remove') and resource ('favorites'), clearly distinguishing the write action from read-only siblings like list_favorites. It also references the related check_favorite_price_drops, giving context on the domain.

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 implicitly defines when to use the tool (to add or remove favorites) and provides a confirmation workflow via list_favorites. It does not explicitly state when not to use alternatives, but the gating and lack of direct outcome make the usage context clear.

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

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

The description discloses a critical behavioral trait: Ozon reports no outcome for this operation, so the agent must confirm via get_lists(sku). This goes beyond annotations (none provided) and adds actionable context about side effects and confirmation workflow. The writes_enabled gating is also mentioned, though its exact meaning is not elaborated.

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 deliver the core purpose, the permission gate, and the confirmation read. No filler, front-loaded with the gating context, and every word earns its place.

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

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

Given the tool's moderate complexity, the description covers purpose, permission gating, no-outcome behavior, and confirmation path. An output schema exists (though its content isn't shown here), which reduces the need to explain return values. Missing are explicit usage conditions and edge-case callouts, but the essential details are present.

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

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

Schema description coverage is 100%, and the parameter descriptions are detailed: add explains boolean semantics, sku notes variant guidance, list_id references get_lists()[].list_id. The description itself adds no extra parameter information beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action: put a product into a collection or wishlist, or take it out. It specifies the resource (list membership) and direction (add/remove). While it doesn't explicitly differentiate from sibling tools like set_favorite, the operation is distinct enough.

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 explicit guidance on when to use this tool versus alternatives. The '[GATED by writes_enabled]' hint implies a permission prerequisite, but there is no mention of preconditions, typical use cases, or when other tools (like set_favorite) should be preferred. The agent must infer usage from the schema and context.

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 burden and does an excellent job. It discloses the gating by writes_enabled, the replace semantics, that an empty list empties the selection, that products not in favorites are silently dropped, and advises checking the returned items count.

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 compact and front-loaded, starting with the gate and core behavior. Every sentence earns its place, including the caveat about favorites and the silent drop, without any redundant fluff.

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 modifies a resource with side effects, so prerequisites, behavioral caveats, and validation guidance are all present. An output schema exists, so return values are not required. The description covers everything needed to call the tool correctly and confidently.

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

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

Schema description coverage is 100%, so the schema already clearly documents both parameters: skus are the full list, not an addition, and uuid comes from list_selections()[].uuid. The description reinforces the replacement behavior but does not add significant new parameter-level meaning beyond what the schema provides.

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

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

The description clearly states a specific verb (Set), resource (which products a selection holds), and scope (as the whole list). It distinguishes itself from sibling tools add_to_selection() and remove_from_selection() by explicitly naming them as alternatives.

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 explicitly says when to use this tool vs alternatives: for 'add this'/'take that out' use add_to_selection()/remove_from_selection(), while this one replaces the whole list. It also gives the prerequisite that products must be in favorites 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?

With no annotations provided, the description carries the full disclosure burden and does so exceptionally well: it flags the write gating (writes_enabled), discloses the outward-facing nature, requires confirmation, and — critically — explains that publication is reviewed by Ozon and returns status 'На модерации' rather than public, which prevents an agent from misinterpreting a non-public response as failure.

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

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

Three compact sentences, each earning its place: the core action is front-loaded in the first sentence, the confirmation requirement in the second, and the essential moderation-outcome caveat in the third. Zero 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?

The tool is a mutation with outward-facing consequences and an output schema present, so return values need no explanation. The description covers gating, confirmation duty, and the moderation delay; the schema covers parameter provenance. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents both parameters, including that uuid comes from list_selections()[].uuid and that public=False returns the selection to link-only. The description adds minimal parameter-specific detail beyond the schema's existing documentation, so the baseline 3 applies.

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

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

States a specific verb pair (publish/unpublish) plus the resource (a selection on the account owner's public profile), with an explicit distinction between the two states. This clearly separates it from content-management siblings like create_selection, edit_selection, and set_selection_items, which operate on selection contents rather than its outward visibility.

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 conveys clear operational context: it is outward-facing, requires confirmation with the user before publishing, and is gated by writes_enabled. This implies when it should and should not be invoked. It stops short of naming explicit sibling alternatives or a when-not-to-use statement, but the context is unambiguous given the unique 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, the description carries the behavioral burden. It discloses that the code is delivered out of band (email, SMS, or flash call), implying the agent must await user input. It also implies the operation is non-destructive by nature of being a login initiation. However, it does not mention potential errors, rate limits, or idempotency, which would strengthen transparency further.

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

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

Two sentences, front-loaded with the purpose, then the usage condition and next step. No 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?

The tool is part of a login flow with session_status and submit_login_code. The description covers when to use, what it does, and what to do next. An output schema exists to describe the return value, so nothing critical is missing for an agent to call it correctly.

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

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

The schema already covers the parameter fully: 'The account's email or phone, as registered with Ozon.' The description repeats this ('account email or phone') without adding new syntax or format details, so it adds no value beyond the schema. With 100% coverage, baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Ask Ozon to send a one-time login code to `login`'. It clearly distinguishes this from sibling tools like submit_login_code (which submits the code) and session_status (which checks status), so an agent can tell them apart without reading schemas.

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 explicitly gives the condition for use: 'Use this when session_status() reports signed_in=false and the kept profile copy did not recover it.' It also instructs the agent to ask the user for the code and pass it to submit_login_code(), providing clear routing to the next step.

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 burden. It discloses that codes are single-use and expire, and that a refusal means the login flow must be restarted. It also instructs the agent to 'keep a copy of the restored profile' – a behavioral directive beyond the tool's own action. It does not explicitly state that completing login mutates session state, but the output schema likely covers the result. This is solid disclosure for a simple auth tool.

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

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

Three sentences with no filler. The main action is front-loaded, followed by a critical behavioral note and a fallback instruction. Every sentence contributes essential 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?

The tool is simple with one parameter and an output schema. The description covers the action, the code's constraints, and the fallback. It doesn't explicitly state the prerequisite of having called start_login, but this is strongly implied by 'finish the login.' The instruction to keep a profile copy is an extra nuance that helps the agent. Given the output schema exists, the description is largely 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?

The input schema already describes the code as 'The one-time code Ozon sent; digits only, as received' – 100% coverage. The description adds the expiry and single-use constraints, which are not in the schema, enhancing the agent's understanding of the parameter's lifecycle. This adds meaning beyond the schema, so it exceeds the baseline of 3.

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

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

The description opens with 'Finish the login with the code Ozon sent' – a specific verb (finish) and resource (login) that clearly states the tool's role. It distinguishes itself from start_login by describing the completion step, and the sibling list confirms start_login exists. The purpose 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 description explicitly names the alternative: 'if it is refused, call start_login() again.' This gives a clear condition and directs the agent to the correct fallback. It also implies this tool should be used after start_login, and the warning about code expiry and single-use adds context on when to retry.

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