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

The description goes far beyond annotations by disclosing that the key is placed in the chat transcript, that it requires the i_understand_key_goes_to_chat flag, that the cabinet is saved locally with chmod 600, and that the key is never echoed. These are critical behavioral details not present in the annotations (readOnlyHint false, idempotentHint true, destructiveHint false).

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

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

The description is well-structured with a clear warning, an args section, and storage details. Every sentence adds value: the warning is critical, the arg explanations are precise, and the storage info reassures about security. It is not verbose despite covering complex topics.

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 all essentials: what the tool does, the security risk, the required flag, parameter formats, auto-naming behavior, and persistence details. An output schema exists, so return values need not be described. Nothing an agent needs to invoke this correctly is missing.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter: credentials as a dict with required fields and concrete examples for Ozon and WB, name as optional with auto-naming fallback to 'main', and i_understand_key_goes_to_chat as a mandatory safety gate. This is exemplary parameter documentation.

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

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

The description clearly states the tool's function: 'Add or update a cabinet (a named set of API credentials), from chat.' It uses a specific verb (add/update) and a concrete resource (cabinet) and provides examples for both Ozon and WB, making its purpose unambiguous and distinguishable from sibling tools like wb_set_key or wb_remove_cabinet.

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 provides a when-to-use versus when-not-to-use directive: it warns that the key goes into the chat transcript and recommends the terminal-free installer as a safer alternative. This gives clear context for choosing this tool over the installer, and implicitly over other in-chat credential 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?

Annotations already declare readOnlyHint=trueaiman, and the description reinforces this with 'nothing here changes data' and adds operational context not in annotations: 'it runs without confirmation.' It also discloses the return envelope and error case. This adds meaningful behavioral context beyond the structured annotations.

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 purpose. Each sentence adds value: scope, target API, safety, arg explanations, and return format. There is no filler or unnecessary repetition.

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

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

For a read-only method with an output schema and clear annotations, the description covers operation selection, argument semantics, related tools, safety, and return envelope. It also gives the target API. An agent has everything needed 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 0%, so the description carries the full burden. It explains every parameter: operation_id as the catalog identifier, path_values for placeholders, query as query-string parameters, and body as the JSON request body. This fully compensates for the schema's lack of field descriptions.

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

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

The description opens with a specific verb-resource pair: 'Execute one READ endpoint from the catalog by operation_id.' It clearly distinguishes itself from write/delete siblings by stating what it does NOT do, and it references the catalog source. This leaves no ambiguity about the tool's core purpose.

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

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

The description explicitly says 'Reads only... To change data use wb_write_method, to delete use wb_delete_method,' naming the exact alternatives and the condition that selects them. It also points to wb_search_methods for obtaining operation_id. This is explicit when-to-use and when-not-to-use 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, but the description adds valuable behavior: it explicitly states the tool does NOT reveal secret values and only reports which variables are set. It also specifies the exact return JSON structure. This goes beyond what annotations convey and helps an agent understand safety and output format.

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: two sentences plus a return-format spec. It front-loads the purpose, then states a key behavioral constraint, and finally gives the exact output. Every sentence adds value with no 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 simple, read-only, parameterless check tool, the description is complete. It explains what it does, what it returns, and a critical safety behavior. With an output schema present and no params, 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?

The tool has zero parameters, so schema coverage is trivially 100%. Per the baseline rule for 0 params, a score of 4 is appropriate. The description adds no parameter details because none exist, and no compensation 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 states a specific verb ('Check') and resource ('whether the required credentials are present in the environment'), and explicitly clarifies it does not reveal secrets. This clearly distinguishes it from other wb_* tools that perform actions or retrieve data. 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 implies this is a pre-flight check for environment credentials but does not explicitly state when to use it versus alternatives (e.g., wb_set_key, wb_add_cabinet). It does not mention exclusion conditions or recommend it before other operations. The intended use case is inferable but not explicit.

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

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

Annotations already provide destructiveHint=true and readOnlyHint=false, so the description's job is lighter. It adds meaningful behavioral context: writes are irreversible, and nothing is sent unless both confirm_write and i_understand_this_modifies_data are true, and it documents the response/error envelope. This goes beyond the annotations without contradicting them.

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 well-structured and front-loaded with the destructive warning, followed by the API link, mandatory confirmation flags, a compact parameter list, and return format. The only weakness is redundancy: the two confirmation flags are stated both in the opening paragraph and again in the Args list. Still, every sentence earns its place.

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

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

For a generic destructive executor with six parameters, the description covers the core needs: what the tool does, where operation_ids come from, how to pass path/query/body values, the mandatory safety flags, and the return/error envelope. It does not mention authentication prerequisites or explicitly route to alternatives, but the output schema and annotations cover some of the remaining 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?

Schema description coverage is 0%, so the description must compensate, and it does. It lists all six parameters with useful meanings: operation_id comes from the catalog, path_values fill placeholders, confirm_write and i_understand_this_modifies_data must be true. Some entries like 'query: query-string parameters' and 'body: JSON request body' are thin, but the critical safety flags and catalog linkage are explained.

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 ('Execute one DESTRUCTIVE endpoint') and clarifies the resource ('deletes or irreversibly changes data'), which clearly separates it from read-only or non-destructive write tools. It does not name a specific endpoint because it is a generic catalog-based executor, but the destructive framing and target API URL make the purpose understandable.

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: use this tool when an operation_id from the Wildberries catalog is destructive, and it points to wb_search_methods for finding operation_ids. However, it does not explicitly contrast with sibling tools like wb_write_method, wb_call_method, or wb_delete_raw, nor does it state when not to use this tool. The guidance is clear but left largely 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description adds the mandatory confirm_write and i_understand_this_modifies_data flags, plus the scope of deletion (any path). It also notes the target API and return format. No contradiction with annotations.

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 well-organized with a clear capability statement up front, followed by the args list. Every sentence adds necessary information, though the target API link could be seen as extra but is helpful context.

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 raw DELETE with 7 parameters and an output schema. The description covers the core behavior, required flags, parameter details, and return format. It lacks edge-case handling details but is adequate 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 0%, so the description must compensate. It explains every parameter: path format, method fixed to DELETE, host override, query, body, and the two required boolean flags. This adds significant meaning beyond the schema field names.

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 deletes data at ANY path, including non-catalog paths, with a specific verb and resource. It distinguishes itself from catalog-based deletion tools (e.g., wb_delete_method) by explicitly mentioning 'any path' and 'not in the catalog'.

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

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

The description implies usage for arbitrary or non-catalog paths, and explicitly requires both confirmation flags, making the invocation conditions clear. It does not explicitly name alternative tools for catalog paths, but the 'including paths not in the catalog' phrasing provides sufficient context to infer when to use this raw variant.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the specific content of the returned record, which is useful context, but it doesn't disclose any additional behavioral traits such as error handling, auth requirements, or side effects. Since annotations cover the read-only nature, this is adequate but not rich.

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

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

A single, front-loaded sentence that lists all relevant fields without any filler. Every word earns its place, and the structure is perfectly readable for an agent scanning for a quick 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?

With an output schema present, the description doesn't need to detail return values. It lists the record's fields, which covers the content. It doesn't mention what happens with an invalid operation_id or how to obtain one, but given the read-only nature and the existence of sibling search tools, this is acceptable. The description is complete enough for the tool's simple role.

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

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

Schema description coverage is 0%, so the description must compensate. The parameter operation_id is only implicitly defined via 'one endpoint.' It doesn't explicitly state that operation_id is the identifier for the endpoint, nor does it provide format or examples. However, the parameter name is self-explanatory and the description implies its role, so it meets the minimum bar.

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: 'Return the full catalog record for one endpoint.' It enumerates the exact fields returned (method, host, path, scope, safety level, pagination style, rate limit, params, doc URL), making it unmistakably distinct from sibling tools like wb_search_methods (search) or wb_call_method (execute). The singular 'one endpoint' clarifies its scope.

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

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

The description clearly implies usage: call this when you have an operation_id and need the full details of a single endpoint. It doesn't explicitly mention alternatives or when not to use it, but the distinction from search/call tools is evident from 'one endpoint' and the listed fields. No exclusions are stated, but the context is clear enough for an agent to infer.

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

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

Annotations already provide readOnlyHint and openWorldHint; the description adds valuable context: cursor fields are auto-managed, max_items (default 10000) protects context, and extra keys are ignored. The truncated flag and page-capping behavior are disclosed beyond what annotations convey. No contradiction with annotations.

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 purpose is front-loaded in the first sentence, followed by a scannable list of supported pagination styles, then a compact Args block. Every sentence earns its place; nothing is redundant.

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

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

Despite an output schema being present, the description still documents the return envelope ({ok, items, total_fetched, pages_fetched, truncated}) and fully covers all 7 parameters, which is critical given 0% schema coverage. A minor gap is the lack of a concrete example of items_path or per-endpoint pagination quirks, but the catalog hub makes this acceptable.

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

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

With 0% schema coverage, the description carries the full burden and largely succeeds: it explains operation_id as a catalog read endpoint, query/body/path_values as base parameters with cursor fields managed, items_path as an array-path override, and defaults for limit and max_items. It could be slightly more explicit about how cursor management interacts with user-supplied query values.

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

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

The description states a specific verb and resource: 'Auto-paginate a read endpoint and return every row in one response.' The read-endpoint scoping distinguishes it from mutation siblings like wb_set_price and from single-call tools like wb_call_method, so an agent can tell them apart.

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

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

The description clearly conveys when to use it — when you want every row from a read endpoint rather than a single page — and enumerates the pagination styles it handles. It stops short of explicitly naming alternatives such as wb_call_method or stating when not to use it, so it lacks an explicit exclusion.

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

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

Annotations already provide readOnlyHint and openWorldHint. Description adds the exact JSON response structure and keys (id, rid, etc.), giving the agent expected output format.

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-sentence description: first sentence states purpose, second shows response structure. No fluff, well 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?

Tool has no parameters, output schema implied by example JSON, annotations cover behavior. Description provides all necessary context for a simple 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?

No parameters; schema coverage 100%. Description doesn't need to add param info. Baseline 4 for 0 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?

Clear verb 'Get', specific resource 'new FBS assembly orders awaiting processing'. Distinct from sibling tools (Ozon products).

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 when-to-use or alternatives mentioned. However, siblings are unrelated, so guidance is less critical, but still absent.

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

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

Annotations already declare readOnlyHint: true and openWorldHint: true, so the safety profile is covered. The description adds valuable behavioral context by specifying the return JSON structure (including 'ok' and 'data.listGoods' with fields like nmID, sizes, discount) and pagination behavior (limit <=1000, offset). This goes beyond the annotations and helps the agent understand the tool's output and constraints. No contradictions with annotations.

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 with the primary purpose in the first sentence. It then lists parameters and return format in a structured, scannable way. Every sentence provides useful information without fluff. The format is efficient for an agent to parse and act upon.

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 read-only get tool, the description is complete: it states the purpose, lists all parameters with constraints, and describes the return format. The output schema is essentially embedded in the description, covering what the agent needs to know to call and interpret results. No critical information is missing for a straightforward 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 0%, so the description must explain parameters. It does so clearly: limit with a max constraint (<=1000), offset as pagination offset, and filter_nm_id as an optional single nmID. This adds meaning beyond the schema, which only provides types and defaults. The description clarifies the purpose and constraints of each parameter, though it doesn't elaborate on what nmID represents, which is a minor gap given domain context.

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

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

The description clearly states the tool's purpose: 'Get current prices and discounts for products'. It identifies the specific API ('Discounts-Prices API') and the resource (products). This distinguishes it from sibling tools like wb_set_price (which sets prices) and other get tools (e.g., wb_get_sales, wb_get_stocks) that target different resources. The verb 'Get' and resource 'prices and discounts' are specific and 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 explains how to use the tool via parameters and return format but does not explicitly state when to choose this over alternatives. While the read-only nature and resource scope are clear, there is no direct mention of when not to use it or when a sibling like wb_set_price would be appropriate. The usage context is implied but not stated explicitly, leaving the agent to infer selection based on the tool name and 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description reinforces the read-only constraint by listing safe verbs. It adds useful behavioral context: the tool returns a JSON envelope {'ok': true, 'status', 'data'} or an error envelope, and notes that some read APIs expect a body. This goes beyond the annotations without contradicting them.

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: the core purpose and scope appear in the first sentence, followed by the API reference link, safety constraints, sibling routing, and a terse parameter list. 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?

For a raw-path tool with an output schema and read-only annotations, the description covers the essential invocation details: path format, method restrictions, host override, query, body, and return envelope. It could mention error behavior in slightly more detail, but the error envelope reference and the output schema cover the main gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains each parameter: path is a full path beginning with '/', method is a safe verb defaulting to GET, host overrides the default, query is query-string parameters, and body is a JSON request body rare on reads. This adds meaning beyond the bare schema titles.

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

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

The description states a specific verb ('Read') and resource ('ANY endpoint by path'), and explicitly distinguishes itself from catalog-based tools by noting it covers endpoints 'missing from the catalog'. It also names sibling tools wb_write_raw and wb_delete_raw for mutation, making its read-only scope 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 says when to use this tool ('Read ANY endpoint by path, including ones missing from the catalog') and when not to ('To change data use wb_write_raw, to delete use wb_delete_raw'). It also restricts to safe verbs (GET, HEAD, OPTIONS), giving clear selection criteria 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?

Annotations already mark readOnlyHint and openWorldHint, so read-only status is covered. The description adds meaningful behavioral context: a rate limit of 1 req/min, the JSON success/error envelope shape, and the row-level fields returned. This goes beyond the annotations and helps set expectations for callers.

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: one sentence states the core purpose and API context, then Args and Returns are clearly sectioned. There is no filler; each line contributes useful information for invoking the tool.

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

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

Given the tool's simplicity (2 parameters, one required) and the presence of an output schema, the description covers everything an agent needs: purpose, parameter formats, flag behavior, rate limiting, and return envelope. No critical gap is evident.

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

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

Schema description coverage is 0%, so the description carries full responsibility for parameter meaning. It defines date_from with RFC3339/MSK format and concrete examples, and explains flag values 0 and 1 with their exact behavioral distinction. This is essential and well done.

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

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

The description opens with a specific verb and resource: 'Get Wildberries sales and returns since a date.' This clearly distinguishes it from sibling tools like wb_get_new_orders or wb_get_stocks, even without comparing schemas. The purpose is immediately identifiable.

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 context — fetching sales and returns relative to a date — and explains the flag semantics for incremental vs dated retrieval. However, it does not explicitly state when to choose this tool over siblings such as wb_get_new_orders or wb_get_prices, nor does it mention exclusions or prerequisites.

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

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

Annotations declare readOnlyHint=true, and the description's 'List all endpoints' is consistent with that. The description adds value by specifying the exact return format: 'JSON list of {operation_id, method, path, safety, summary}'. This goes beyond the annotation and provides concrete expectations. It does not mention auth or rate limits, but given the read-only annotation, this is acceptable.

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 well-structured: a one-sentence main purpose, an Args block, and a Returns line. It front-loads the core functionality and then provides parameter guidance and output format without any redundant text. Every sentence earns its place.

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

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

For a simple tool with one parameter and an output schema (indicated as present), the description covers the purpose, how to obtain the parameter, and the return structure. It does not explain the 'safety' field, but that is likely covered by the output schema. It also omits error handling details, which is acceptable for a read-only listing operation. Overall, it is adequate 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 description coverage is 0% for the 'section' parameter, so the description must compensate. It does so by explaining that the parameter is a section name, referencing wb_list_sections for valid values, and giving an example ('statistics'). This provides the necessary semantic context that the bare string type in the schema lacks.

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

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

The description uses a specific verb 'list' and a clear resource 'endpoints in one section', immediately distinguishing it from sibling tools like wb_list_sections (which lists sections) and wb_describe_method (which describes a single method). It also provides a concrete example of a section name, making the 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?

The description explicitly references wb_list_sections as the source for valid section names, which is a clear prerequisite and guides the user on how to obtain the parameter value. It does not explicitly mention alternative tools, but the context of the family makes it evident that this tool is for exploring a section's endpoints rather than a specific method. The guidance is implicit but sufficient.

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

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

Annotations already mark readOnlyHint and openWorldHint, but the description adds valuable behavioral context beyond those: it explicitly states the rate limit (1 req/min), clarifies that stocks are a point-in-time snapshot with no history, and describes the return envelope. This is rich, non-contradictory detail that helps the agent set expectations.

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 well-structured: a one-line purpose, a note on snapshot semantics, then Args and Returns sections. It front-loads the core purpose and rate limit, and every sentence adds value—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's simplicity (one optional parameter, no required fields) and that an output schema exists, the description covers all essential operational aspects: purpose, rate limit, parameter semantics, and return format. 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?

The schema only declares a default value with zero description coverage, so the description fully compensates. It explains the parameter format (RFC3339 date), its default, and its effect ('returns everything in stock now'). This gives the agent clear, actionable meaning beyond the bare 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 opens with a specific verb and resource: 'Get the current Wildberries stock snapshot.' It clearly identifies the platform (Wildberries) and the data (stock). While it doesn't name sibling tools, the resource is unambiguous and the tool name aligns, so an agent can easily distinguish it from tools like wb_get_sales or wb_get_prices.

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 a concrete usage hint: 'Use an early date_from to get the full current set.' This guides parameter selection effectively. However, it does not explicitly state when to use this tool over alternatives (e.g., avito_get_stocks or ozon_get_stocks), though the platform is implied by the name. The hint is useful but not a full when/when-not breakdown.

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

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

Annotations already include readOnlyHint=true, so the safety profile is covered. The description adds useful detail about the returned content, such as ordered steps and common mistakes, but does not disclose things like auth requirements, error behavior, or rate limits. This is acceptable for a simple read-only getter, but not exceptional.

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

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

The description is two dense sentences: the first states what is returned, the second documents the argument. There is no filler 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?

With one required string parameter, an output schema, and a readOnly annotation, the description provides everything needed to invoke the tool: it explains the return contents and tells the agent where to get the workflow name. No additional context 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 provides only a string 'name' with no description, so the 0% schema coverage means the description must compensate. It does so by explaining that 'name' is a workflow name and pointing to {svc}_list_workflows for valid values. This is sufficient for a single simple parameter, though no format or example is given.

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: 'Return the full plan for one workflow' and enumerates the contents (ordered steps, operation_id, why, interpretation guidance, mistakes). This clearly distinguishes it from sibling tools like wb_list_workflows, which list workflows rather than retrieve one plan.

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

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

The description implies the right usage context: use it when you need the full plan for a single workflow, not a list. The Args note 'see {svc}_list_workflows' tells the agent where to obtain a valid name. It could more explicitly contrast with alternatives, 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds valuable behavioral context: it returns JSON with a specific shape (active, cabinets, fields_needed) and explicitly states that secret values are never returned. This is meaningful beyond the annotations and helps an agent trust the tool with sensitive data.

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 earning its place: what it lists, what it returns, and a security guarantee. The most important information (purpose) is front-loaded, and the JSON shape is compactly shown.

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

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

For a zero-parameter read-only tool, the description is nearly complete. It covers purpose, output shape, and the key security behavior. The only minor gap is that it doesn't explain what 'fields_needed' means or when it would be populated, but the output schema and the tool's simple nature make this a small omission.

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

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

The tool has zero parameters, so there is nothing for the description to explain about inputs. The description instead clarifies the output shape, which is the relevant semantic content for a parameterless tool. Baseline 4 is appropriate for 0-param tools.

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 lists configured cabinets for a marketplace and identifies which one is active. It distinguishes itself from sibling tools like wb_use_cabinet (which selects a cabinet) and wb_add_cabinet/remove_cabinet (which modify the set). The verb 'list' plus the resource 'cabinets' is specific and 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 implies this is a read-only inspection tool for discovering available cabinets and the active one, which is clear context for when to use it. It doesn't explicitly name alternatives or state when not to use it, but the sibling set (wb_use_cabinet, wb_add_cabinet, wb_remove_cabinet) makes the distinction inferable. A small gap: no explicit statement like 'use wb_use_cabinet to switch the active cabinet.'

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

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

Annotations already flag readOnlyHint=true and openWorldHint=false, so the safety profile is handled. The description adds the counting behavior and audited by the 'catalog endpoints' phrase, but provides little beyond what annotations and the tool name convey; it does say it returns a list.

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

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

One sentence, front-loaded with the verb and resource, and every phrase earns its place. It states what is listed and the added beneficial detail of 'how many catalog endpoints' in two clauses without waste.

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

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

A zero-parameter read-only listing tool with an output schema. The description contains all the caller needs to know to select it, expect it to be non-mutating, and understand what it returns. The output schema preserves the return details from needing to be described here.

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

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

The tool takes zero parameters and has 100% schema coverage, so parameter semantics are the baseline: the description does not need to explain parameters. Nothing is missing; no additional parameter usage context is required.

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, 'List', on a concrete resource, 'API sections', and adds precise output detail: 'how many catalog endpoints each contains.' This clearly differentiates it from siblings like wb_get_section (singular section retrieval) and wb_search_methods (searching for methods).

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

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

The use case is implied rather than stated: use this tool when you need to enumerate available API sections and see endpoint counts. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternative tools like wb_get_section or wb_map.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds value by specifying the return format (JSON array with objects containing name, category, when_to_use) and that it returns only ready-made recipes, which is useful context for agents deciding whether to use this or another 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, with three sentences that each carry weight: what it does, what it returns, and how to proceed to get details. It is front-loaded with the core purpose and immediately points to the sibling tool.

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

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

Given zero parameters (no schema complexity) and the presence of an output schema, the description is complete. It tells the agent what the output looks like (JSON with name, category, when_to_use) and directs them to wb_get_workflow for details, covering all necessary information for correct invocation and usage.

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 parametersanding schema coverage is 100% (n/a), the description clearly explains the return structure and the purpose. Even though there are no parameters to document, the description compensates by clarifying what the returned JSON contains, which is essential for the agent to use the 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 clearly states the tool lists ready-made analytical workflows (recipes) for the marketplace, with a specific verb ('List') and resource ('workflows'). It distinguishes itself from the sibling wb_get_workflow by noting that get_workflow fetches the full plan for one workflow, so the agent can tell them apart.

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 to use {svc}_get_workflow to fetch the full step-by-step plan for one workflow, providing clear routing to the alternative. It does not mention when not to use this tool (e.g., when a specific workflow is needed), but the context is clear enough for a listing tool.

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

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

The description explains what the tool returns cognitively (a map/orientation) and how to use it, which supplements the readOnlyHint annotation. It adds context about the entity parameter and 'you are here' positioning, so agents understand the tool is a discovery utility with 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 compact and front-loaded with the key idea, followed by concrete invocation guidance and a closing recommendation. Every sentence adds value and none are redundant.

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

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

For a read-only map tool with one optional parameter and an output schema present, the description provides enough context for correct invocation. It explains the two valid invocation patterns and conveys when to use the tool before exploring other methods.

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

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

Schema coverage is 0% and the only parameter has no description. The tool description compensates fully by explaining the default behavior ('Call with no args') and giving representative values like entity='reviews', plus indicating that other entity names map to the same pattern.

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 a specific purpose: a capability map that lists business entities and the go-to methods for each. It also distinguishes itself from operational tools by describing the 'big picture' orientation 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?

The description gives clear usage context: call with no args for the whole map, or pass an entity to list its methods, and 'use this before guessing.' It does not explicitly name alternatives or exclusion conditions, but the intent is obvious enough for an agent to select it correctly.

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

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

The annotations already flag destructiveHint=true, but the description adds a valuable behavioral detail: 'If it was active, another becomes active.' This discloses a side effect beyond the structured annotations. It does not mention error behavior or whether removal is reversible, but the key destructive behavior is addressed.

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 exceptionally short: a purpose sentence, a relevant behavioral sentence, and a simple parameter mapping. There is no filler or redundant material, and the key 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?

For a one-parameter destructive tool with an output schema and destructiveHint annotation, the description conveys the core action and the most important side effect. The notion of 'another becomes active' is left a bit vague, but it is sufficient for an agent to understand and invoke 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?

With schema description coverage at 0%, the description's 'name: the cabinet to remove' is the only semantic explanation for the single parameter. It clarifies that the name identifies the cabinet being deleted, though it is still fairly close to a natural reading of the parameter name itself.

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

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

The opening phrase 'Delete a stored cabinet' is a clear verb+resource statement that distinguishes this tool from listing, adding, or using cabinets. It does not explicitly reference a sibling tool, but the operation and object are unambiguous enough for an agent to know what it does.

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 does not state when to use this tool versus alternatives like wb_add_cabinet or wb_use_cabinet. It does not explain circumstances that would make deletion inappropriate, nor does it point to any other tool for related tasks.

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

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

Annotations already indicate readOnlyHint=true, so the safe read-only nature is covered. The description adds useful behavioral context beyond that: keyword search works in Russian and English, results are returned as a JSON list, and are ordered best first. This is meaningful additional information.

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, front-loaded with the primary purpose, and clearly separates arguments from return behavior. Every sentence contributes either purpose, parameter semantics, or result expectations 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?

For a two-parameter search tool with an output schema already present, the description is complete: it covers what the tool does, what inputs look like, the return type, ordering, and multilingual behavior. No essential calling details are 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 0%, so the description carries the full burden for parameter understanding. It explains 'query' as free text with concrete examples and 'limit' as max results with a 1-50 range)Skip the schema only provides type and default. This fully compensates for the missing schema descriptions.

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: 'Search the endpoint catalog by keyword.' This clearly differentiates the tool from sibling catalog-related tools like wb_list_sections, wb_describe_method, and wb_map.

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

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

The tool's usage context is clear: use it when you need to find endpoints by keyword. The description even shows example queries like 'остатки' and 'stocks'. It does not explicitly name alternative tools or state when not to use it, but the search-specific framing provides sufficient context without being misleading.

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 key behaviors beyond annotations: the key enters the chat transcript, requires an explicit confirmation flag, is stored locally with chmod 600, never echoed back, and is validated against the marketplace. These details add critical context not present in the annotations, and there is no contradiction.

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 earns its place: it leads with the purpose, immediately flags the security warning, lists parameters clearly, and concludes with post-success behavior. No superfluous details; the structure aids quick comprehension.

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 security-sensitive and complex, yet the description covers the full lifecycle: purpose, prerequisites, parameter details, safety precautions, default behavior, and success outcomes. Even though an output schema exists, the description adds the shop name reporting detail, making it complete for safe and 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?

With schema description coverage at 0%, the description fully compensates by explaining all three parameters: credentials (required fields in a dict), cabinet (default behavior and naming fallback), and i_understand_key_goes_to_chat (must be true). This provides complete meaning beyond the bare 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 ('Change / rotate') and a clear resource ('the API key'), with an explicit use case ('old one expired or leaked'). It distinguishes from sibling set_key tools by specifying the platform (wb) and the chat context, making it 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 gives explicit when-to-use guidance (key expired/leaked) and contrasts with the safe installer alternative. It also provides best-practice guidance (use a scoped key, rotate in seller cabinet) and explains the default cabinet selection logic, so an agent knows exactly when and how to invoke it.

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

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

Beyond annotations (readOnlyHint=false, openWorldHint=true), the description adds important behavioral detail: confirm_write gates the live update, prices 3x below the old one trigger WB quarantine, and the endpoint returns an upload ID to poll via wb_prices_history_tasks. This meaningfully enriches the agent's understanding of side effects and follow-up.

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 well structured: a one-line purpose, a crucial warning, an args list, and the return contract. No sentence is wasted; the quarantine caveat and polling instruction each carry operational value.

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

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

For a write operation with side effects, the description covers the required confirmation flag, a domain-specific risk (quarantine), all parameter semantics, and the asynchronous response pattern. An agent has everything needed to invoke it correctly and know what happens next.

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

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

Schema description coverage is 0%, but the description compensates fully: nm_id is defined as the product nmID, price as new base price in rubles (integer), discount as percent 0-99, and confirm_write as the flag that must be true. Units, ranges, and meaning are all supplied, exceeding the bare schema types.

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?

Description names a precise action—'Set price and discount for ONE product'—and scopes it to the Discounts-Prices API. The explicit 'WRITE' marker plus 'live price' makes the tool's mutating nature unmistakable, distinguishing it from read-only siblings like wb_get_prices.

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?

Description clearly states the mandatory precondition: 'Requires confirm_write=true' and 'must be true to actually send the change.' It gives a concrete consequence (price quarantine) but does not explicitly name an alternative sibling or state when not to use it, so it stops short of full when-vs-alternative 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?

Annotations already declare idempotentHint=true and readOnlyHint=false. The description adds the behavioral consequence that subsequent calls use the new cabinet's credentials, which is useful. However, it doesn't mention error handling (e.g., invalid cabinet name) or any other side effects. It provides moderate extra context beyond annotations.

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: two sentences and a parameter explanation. It front-loads the purpose and effect, with no fluff or repetition. 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?

Given the tool's simplicity (one parameter, output schema present), the description covers the core purpose and the prerequisite for finding a valid name. It could mention behavior on invalid input, but that is a minor gap. Overall, it is complete enough 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 coverage is 0% for the name parameter, so the description must compensate. It explains that 'name' is the cabinet to activate and directs the user to wb_list_cabinets for valid values. This adds meaning and provides a reference for acquiring the parameter, going beyond the bare schema definition.

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

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

The description clearly states the action (switch) and the resource (active cabinet), and explains the effect (subsequent API calls use its credentials). This distinguishes it from sibling tools like wb_list_cabinets or wb_add_cabinet, which have different verbs and purposes.

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 points to wb_list_cabinets as the source for valid cabinet names, implying you should list before switching. While it doesn't explicitly contrast with alternative actions (add, remove, set_key), the context makes it clear this is for switching between existing cabinets. The guidance is present but not exhaustive.

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?

It discloses the critical requirement that confirm_write must be true (nothing is sent without it) and describes the return format ({"ok": true, "status", "data"} or error envelope). This adds meaningful behavior beyond the annotations, which only indicate not read-only and not destructive. No contradiction with annotations.

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?

Concise and well-structured: purpose front-loaded, sibling differentiation immediately after, then a bulleted arg list, then return format. No fluff; every sentence earns its place.

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

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

For a generic catalog-based write method, the description covers essentials: target API, confirm flag, parameter semantics, return format, and how to find operation_id. The only minor gap is lack of examples or deeper format guidance for path_values/body, but given the catalog context and output schema presence, it is reasonably 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 0%, so the description carries the full burden. It explains each parameter's purpose: operation_id (catalog id), path_values (for placeholders), query, body, and confirm_write (must be true). It clarifies the confirm_write requirement despite the schema's default false, which is valuable. Slightly light on detailed formats but adequate.

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 it executes a WRITE endpoint for create/update operations, and explicitly differentiates from delete (wb_delete_method) and read (wb_call_method). The verb+resource is specific and the sibling distinction is unambiguous.

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

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

It explicitly says irreversible operations belong in wb_delete_method and reads in wb_call_method, and points to wb_search_methods for finding operation_id. This provides clear when-to-use and when-not-to-use 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the write nature is known. The description adds the confirm_write=true requirement and the return envelope, which are valuable. It does not fully disclose side effects (e.g., overwrite behavior), but 'Create or update' covers the basics. With annotations present, this is adequate.

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 well-structured: purpose, API reference, method constraint, then a clear Args list. The parameter list is necessary given schema underdescription, and there is no fluff. 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?

Covers all parameters, method constraints, confirm_write requirement, and return format. Since an output schema exists, return details are handled. Authentication is likely managed elsewhere (e.g., via wb_check_auth). No missing information that would prevent an agent from calling 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 has zero description coverage (coverage 0%), so this description is the only source of parameter meaning. Each parameter is explained with constraints: method must be POST/PUT/PATCH, path starts with '/', host override, query, body, and confirm_write must be true. This fully compensates for the schema's lack of descriptions.

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

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

States a specific verb and resource: 'Create or update data at ANY path'. Clearly distinguishes from siblings like wb_write_method by noting 'including paths not in the catalog' and restricting to POST, PUT, PATCH. 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?

Provides clear context that this is for arbitrary writes, especially to uncatalogued paths, which implies when to use. It does not explicitly name alternatives or when-not conditions, but the 'not in the catalog' phrase effectively differentiates from catalog-based tools. Slight improvement would be explicit routing to wb_write_method.

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