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

Beyond annotations, it discloses that the key is placed in the transcript, that the credential persists to ~/.marketplace-mcp/cabinets.json, that the file gets chmod 600, and that the key is never echoed. These side effects are valuable and not present in annotations, and nothing contradicts readOnly/idempotent hints.

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 security warning before transitioning to parameters. Every sentence adds necessary information; the warning, alternative, and parameter examples are all purposeful.

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 is very complete for a write tool: security, storage, permissions, parameter shapes, and fallback naming are all covered. The only minor gap is the unresolved '({fields})' placeholder for services beyond Ozon/WB, and it does not spell out update-overwrite semantics, though output schema and annotations cover some of the remainder.

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%, but the description compensates fully: it explains credentials as a dict, gives concrete Ozon and WB shapes, defines optional name with fallback behavior, and explains the i_understand_key_goes_to_chat gate. This is exactly the meaning the bare schema lacks.

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

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

The description states a specific action ('Add or update') on a well-defined resource ('cabinet' = named set of API credentials) and scopes it clearly ('from chat'). This sits apart from siblings like remove/use/list by verb and resource, and defines the core object.

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 warns that the key enters the chat transcript, requires i_understand_key_goes_to_chat=true, and names a concrete safer alternative (installer) for cases where key-in-chat is unacceptable. This is clear when-to-use / 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?

Beyond the readOnlyHint annotation, it discloses that reads run without confirmation, that the response is a JSON envelope or error envelope, and that some read endpoints accept a body. These details help the agent predict runtime behavior and error handling.

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 purpose, and each sentence earns its place: purpose, target API, read-only confirmation note, sibling routing, parameter summary, and return shape. 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 read-only catalog call tool with an output schema and helpful annotations, the description covers target API, lookup method for operation_id, parameter semantics, sibling alternatives, and error returns. 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 0%, but the description compensates by explaining operation_id as catalog id, path_values as placeholders, query as query-string parameters, and body as an optional JSON request body. It adds meaning for all four parameters beyond raw schema properties.

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 READ endpoint from the catalog by operation_id, identifying both the resource (catalog endpoints) and the identifier mechanism. It explicitly contrasts itself against write and delete siblings, so an agent can distinguish it from sbis_write_method and sbis_delete_method without opening 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 says exactly when to use this tool: for read-only catalog operations, and explicitly routes write and delete behavior to named siblings. It also directs the agent to sbis_search_methods to find operation_id, which is practical usage 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?

The description explicitly states that the tool does NOT reveal secret values, only reports which variables are set. This is critical behavioral disclosure beyond the readOnlyHint annotation. It also describes the exact return shape, which is valuable given the output schema is not shown in detail.

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 first sentence states the core purpose, the second clarifies a critical non-behavior, and the third gives the return format. Every sentence earns its place 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 zero-parameter, read-only tool, the description is complete. It covers what the tool does, what it doesn't do, and what it returns. The annotations confirm the read-only nature, and the sibling list provides context for when this might be used.

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 doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description appropriately focuses on behavior and return value instead.

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: checking whether required credentials are present in the environment. It uses a specific verb ('check') and resource ('credentials'), and explicitly distinguishes itself from other SBIS tools by focusing on auth state rather than data operations.

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 when to use this tool: before operations that require credentials. It doesn't explicitly name alternatives or exclusions, but the context of checking auth readiness is clear. Given the sibling tools are all data operations, the usage context is reasonably inferable.

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 adds valuable context beyond the annotations' destructiveHint=true and readOnlyHint=false: it says the operation deletes or irreversibly changes data, and that no request is sent unless both confirm_write=true and i_understand_this_modifies_data=true are set. It also discloses a stable return shape: the ok JSON or error envelope.

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 destructive warning is front-loaded, and every line earns its place: the danger statement, API reference, mandatory safety checks, argument meanings, and return contract. It is compact yet information-dense without repeating the schema verbatim.

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 dispatcher, the description covers operation lookup via sbis_search_methods, parameter construction, the safety gates, and expected response shape. It does not detail authentication or the exact error-envelope contents, but given the sibling tools for auth and an output schema, the description is sufficiently 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?

Despite 0% schema description coverage, the description explains all six parameters: operation_id from the catalog, path_values for path placeholders, query string parameters, JSON body, and the must-be-true confirmation flags. It stops short of giving concrete examples or value constraints, but provides enough meaning beyond 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?

The description states a clear verb and resource: it executes a destructive endpoint that deletes or irreversibly changes data, and ties it to an operation_id from the catalog. It does not explicitly contrast itself with related siblings like sbis_delete_raw or sbis_write_method, so the distinguishing boundary is slightly implicit.

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

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

It gives clear operational guidance: operation_id comes from sbis_search_methods, and the two confirmation flags must be true before anything is sent. However, it does not explicitly state when to choose this tool over destructive or non-destructive alternatives, such as sbis_call_method, sbis_write_method, or sbis_delete_raw.

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 destructiveHint=true, and the description adds meaningful behavioral context: deletion is only allowed with confirm_write=true and i_understand_this_modifies_data=true, it is DELETE-only, and it returns a documented JSON envelope. This goes beyond the annotation baseline without contradicting 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 well-organized with a front-loaded warning, a clear Args list, and a return note. There is minor redundancy in stating 'DELETE only' and then repeating method=DELETE, and the confirmation requirement is stated twice, but overall every section 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 destructive, open-world nature and zero schema description coverage, the description covers all parameters, safety requirements, and the return envelope. It includes a link to the target API and enough context for an agent to invoke it safely, though examples or error-envelope details would make it 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?

Schema description coverage is 0%, so the description carries the full burden. It documents all 7 parameters with meaningful summaries: path format, method, host default, query, body, and the two mandatory confirmation flags. It could add more detail on query/body formats, but it provides solid coverage where the schema provides none.

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 and resource: 'Delete data at ANY path, including paths not in the catalog.' This clearly distinguishes it from catalog-scoped delete operations and immediately conveys the raw, open-world nature of the tool.

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

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

The description provides clear operational context ('ANY path', 'DELETE only', mandatory confirmation flags), but it does not explicitly name alternatives or state when not to use this tool versus siblings like sbis_delete_method. The usage scenario is implied rather than contrasted.

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 declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds the composition of the returned catalog record, which is useful context, but does not disclose any additional behavioral traits such as authentication requirements or source of the operation_id. A 3 reflects that annotations carry the main behavioral burden.

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

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

The description is a single front-loaded sentence that lists the record fields without filler. Every clause earns its place by telling the agent what the tool returns.

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

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

Because an output schema exists, the description need not explain return values, though it does list them. It still omits how to obtain the required operation_id and any usage context relative to sibling tools, leaving gaps for a read-only metadata lookup.

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

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

Schema description coverage is 0% and the description never names the required 'operation_id' parameter or explains its format or source. The phrase 'for one endpoint' loosely implies that the parameter identifies an endpoint, but this is not sufficient compensation for the missing 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 uses a specific verb ('Return') and a clear resource ('full catalog record for one endpoint'), then enumerates the record's fields. It does not name or explicitly contrast with siblings like sbis_search_methods or sbis_call_method, so it falls short of full sibling differentiation.

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

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

The description states what is returned but gives no guidance on when to use this tool versus alternatives such as sbis_search_methods, sbis_call_method, or sbis_get_section. It implies the tool is for a known single endpoint, but offers no conditions, prerequisites, or 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?

Annotations declare readOnlyHint=true, and the description aligns by calling it a 'read endpoint.' It adds value beyond annotations by explaining the pagination mechanism, the automatic path detection, the max_items hard cap to protect context, and the exact return JSON structure including the 'truncated' flag. It could mention potential errors or rate limits, but for a read operation 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 well-structured: the opening sentence states the core purpose, followed by a brief note on pagination styles, then a clean Args list, and finally the return format. Every sentence earns its place, and the most important information (auto-pagination) is front-loaded. It is detailed but not verbose.

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 complexity (multiple pagination styles, parameter overrides, and a safety cap), the description covers all essential aspects: what it does, how it handles pagination, what each parameter does, and the return shape. The output schema is mentioned, which offloads return structure details. No critical information 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?

Despite 0% schema description coverage, the description's 'Args' section explains every parameter: operation_id (read endpoint from catalog), query/body/path_values (base params, cursor fields managed), items_path (override), limit (page size), max_items (hard cap). This fully compensates for the schema gap and adds critical meaning, such as the default of 10000 for max_items and the automatic management of cursor fields.

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 starts with a specific verb and resource: 'Auto-paginate a read endpoint and return every row in one response.' It clearly distinguishes itself from siblings like sbis_get_raw (which fetches a single page) and sbis_call_method (generic call) by emphasizing the auto-pagination and aggregation behavior.

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 pagination styles it handles (offset, last_id, cursor, page, lastChangeDate), which implies it should be used for endpoints that use any of these styles. It also mentions that cursor fields are managed automatically, indicating the tool is designed for bulk retrieval. However, it does not explicitly name alternatives 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?

Annotations indicate readOnlyHint and openWorldHint, and the description aligns by stating safe verbs and read-only purpose. It adds valuable context about the host override, query parameters, and the response envelope format, which are not fully covered by annotations. Since the description does not contradict annotations and provides useful behavioral details, a 4 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?

The description is compact but information-dense, with clear sections for purpose, API reference, verb constraints, argument explanations, and return format. It front-loads the core purpose and distinguishes from siblings early. Every sentence contributes, with 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 complexity (raw access with 5 parameters) and the presence of an output schema, the description is complete: it explains the path, method, host, query, body, and return envelope/formats. It also addresses edge cases (missing catalog endpoints, body on reads) and provides the API reference for further context, making it fully sufficient 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 0%, so the description compensates well by explaining each parameter's purpose: path is the full path, method is the safe verb with GET default, host is an override, query is query-string parameters, and body is rare but possible. This adds meaning beyond the bare schema, though it could be slightly more explicit about the format of 'query' (e.g., as an object vs string).

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 reads ANY endpoint by path, explicitly including ones missing from the catalog. It specifies the target API and the safe verbs allowed, distinguishing it from sibling tools that write or delete. The mention of 'raw' and 'path' makes its role unmistakable.

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 sbis_write_raw for changes and sbis_delete_raw for deletions, providing clear exclusions and alternatives. It also specifies safe verbs (GET, HEAD, OPTIONS) and notes that some reads may require a body, guiding the agent on when and how to use the 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 the return format ('Returns JSON list of {operation_id, method, path, safety, summary}'), which goes beyond the readOnlyHint annotation. It also clarifies the input parameter's source, adding context. No contradictions with annotations. It does not describe error behavior, but for a read-only listing tool, this is sufficiently 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 extremely concise and well-structured: a one-sentence purpose, then an 'Args' section with parameter explanation, and a 'Returns' section with the output format. Every sentence contributes value, and the main action 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 simple tool with one parameter and a defined output, the description provides all necessary context: what it does, how to obtain the parameter, and what the result looks like. It references sbis_list_sections as a prerequisite, which completes the usage context. Nothing critical 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 sole parameter 'section' has 0% schema description coverage, but the description compensates fully by specifying it is a section name, referencing sbis_list_sections for valid values, and providing an example ('statistics'). This gives the agent complete semantic understanding of the parameter.

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

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

The description clearly states the action 'List all endpoints in one section' with a specific resource (section). It distinguishes from siblings like sbis_list_sections, which lists sections, and sbis_search_methods, which searches methods. The verb-resource pairing 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 provides usage guidance by referencing 'see sbis_list_sections' to obtain valid section names and gives an example ('statistics'). It implies that this tool is for enumerating endpoints in a specific section, but it does not explicitly state when not to use alternatives or provide exclusions. Still, the reference to the sister tool is a clear contextual pointer.

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 description adds value by stating that secret values are never returned, which is crucial safety context. It also discloses the return JSON structure, going beyond the annotation.

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 the core purpose front-loaded, followed by a compact return spec and a critical security note. Every word earns its place; 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?

For a no-argument read-only tool with an output schema, the description fully covers what an agent needs: what it does, what it returns, and a safety guarantee. 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?

There are zero parameters and 100% schema coverage, so the description correctly omits parameter details. The baseline for 0 params is 4, and the description adds no unnecessary info.

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 explicitly states it lists configured cabinets and identifies the active one, which is a specific verb+resource. It clearly distinguishes from sibling tools like sbis_add_cabinet, sbis_use_cabinet, and sbis_remove_cabinet by being a read 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 implies usage context (to see configuration and active cabinet) but does not explicitly mention alternatives or when not to use it. Given the sibling set, the intent is clear, but explicit routing would improve it.

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

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

Annotations declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the per-section count but doesn't mention pagination, response format, or ordering – marginal added context beyond structured fields.

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

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

One sentence, front-loaded with the verb and resource, and includes the key extra detail (endpoint counts) 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?

With an output schema present, the description needn't explain return values, and the tool has no inputs. The definition is adequate for a simple list operation, though it could mention whether sections are nested or if counts are exact.

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

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

Zero parameters, so no parameter semantics to convey. Baseline for a parameterless tool is 4; nothing misleading or missing on this dimension.

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 clear verb+resource ('List API sections') and adds that it returns endpoint counts per section. However, it does not explicitly distinguish from siblings like sbis_get_section, which likely retrieves a single section, leaving some differentiation to inference.

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

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

No guidance on when to use this versus alternatives. An agent must infer that this is for a top-level overview before drilling into a specific section with sbis_get_section.

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 description does not need to repeat that. It adds behavioral detail beyond the annotation: calling with no args shows the whole map, passing an entity filters to that entity's methods. It also conveys the tool's non-destructive, orientation-focused nature without contradicting the read-only hint.

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 filler. It front-loads the core purpose ('The big picture') and then gives actionable usage instructions and an example. Every word contributes value, and the structure is easy to scan.

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 optional parameter and an existing output schema, the description is quite complete. It explains both call patterns and the orientation purpose. It could mention that the output is a list of methods or entities, but the output schema presumably covers that. It also could reference related sibling tools, but the description's 'before guessing' guidance sufficiently sets expectations.

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 carries the full burden of explaining the 'entity' parameter. It does so thoroughly: no args yields the full map, and passing a value like 'reviews' lists all methods for that entity. It also provides illustrative examples of valid values. This fully compensates for the missing schema documentation.

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

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

The description clearly states the tool's role as a map of business entities and the go-to methods for each, using a specific verb and resource. It distinguishes itself from siblings by framing itself as an orientation tool ('you are here') and giving concrete examples like entity="reviews". The purpose is unmistakable and not a tautology.

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 usage context: 'Use this before guessing — it orients you fast.' It explains both invocation modes (no args vs. entity argument) and implies it is the first step before other tools. However, it does not explicitly name alternative tools or state when not to use it, so it falls 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is known. The description adds a useful behavioral detail: if the removed cabinet was active, another becomes active. This goes beyond the annotations. However, it doesn't disclose what 'another becomes active' means (which cabinet, how chosen), nor any side effects on stored data or auth state. With annotations covering the destructive hint, a 3 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?

The description is short and front-loaded: the main action is in the first sentence, and the parameter explanation follows. Every sentence earns its place. It could be slightly more structured (e.g., separating the parameter doc), but it's efficient and readable.

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 required parameter, an output schema, and annotations covering destructiveness. The description covers the core action and the parameter. However, it doesn't explain the return value (despite an output schema existing, the description could still clarify what the agent should expect), nor the selection logic for the new active cabinet. For a destructive operation, this is a moderate gap.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the only parameter ('name: the cabinet to remove'), which adds meaning beyond the schema's bare 'Name' title. However, it doesn't specify the expected format (e.g., exact cabinet name, case sensitivity, whether it's a path or ID). Since there is only one parameter and it is explained, a 3 is fair.

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 ('Delete a stored cabinet') and the resource ('cabinet'), which distinguishes it from sibling tools like sbis_add_cabinet and sbis_list_cabinets. It also adds a behavioral note about active cabinet replacement, which helps clarify the tool's effect. However, it doesn't explicitly name sibling alternatives, so it's clear but not fully differentiated.

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 when to use this tool: when you need to remove a stored cabinet. It also implies a consequence (if active, another becomes active), which gives some context. However, it doesn't explicitly state when not to use it or mention alternatives like sbis_delete_method or sbis_delete_raw, so the guidance is implied rather than 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 declare readOnlyHint=true and openWorldHint=false, so this is a safe read-only operation. The description adds useful behavioral context beyond annotations: queries work in Russian and Englishcars and results are returned as a JSON list ordered best-first. No contradictions detected.

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: a one-sentence purpose, two concise argument definitions, and one line for return behavior. Every sentence earns its place with no filler or 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 two-parameter read-only search tool with an output schema, the description covers inputs, supported languages, result ordering, and return type. It could mention how to follow up with sbis_describe_method after finding a match, but nothing essential is missing 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 description coverage is 0%, so the description fully compensates. It explains query as free text with concrete Russian and English examples, and defines limit as max results with a 1-50 range. This adds meaningful meaning beyond the raw 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 states a specific verb and resource: 'Search the endpoint catalog by keyword'. It also names supported languages and the return format, making the tool's role clear and easily distinguished from sibling call/write/delete/get 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 clearly implies use when you need to discover endpoints by free-text keyword rather than invoking them, and notes results are ordered best-first. It does not explicitly name alternatives such as sbis_describe_method or sbis_get_section, but the usage 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?

Annotations only cover idempotency and destructive potential, but the description adds much more: the key goes into the chat transcript, a confirm flag is required, the key is validated and saved locally with chmod 600, never echoed back, and the shop name is reported on success. No contradiction with annotations 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 organized: purpose, warning, args, and success behavior. It stays focused and front-loads the most important caveat. The only blemish is the unresolved '{fields}' placeholder, which makes it slightly less polished, but it is not verbose or 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?

The description covers the hazard, the required permission flag, cabinet fallback logic, and post-success validation. However, it omits the actual required fields for the credentials object, which is essential since the schema provides no property definitions and coverage is 0%. This prevents an agent from constructing a valid call without further 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?

With 0% schema description coverage, the description must carry the parameter semantics. It explains cabinet defaulting and the i_understand flag, but credentials is only described as 'dict with the required fields ({fields})' – a placeholder rather than actual field names. This is a critical gap for correct invocation.

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: 'Change / rotate the API key from chat', with a concrete use case ('old one expired or leaked'). This clearly distinguishes it from all sibling tools, none of which handle key rotation.

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 the tool (key expired or leaked), warns about the key entering the chat transcript, and names a safer alternative (the installer). It also advises using a scoped key and rotating in the seller cabinet if exposed, leaving no doubt about selection and precautions.

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 the state-changing effect: switching the active cabinet and affecting subsequent API calls. This complements the annotations, especially idempotentHint=true, by clarifying the operational consequence. It does not cover error or persistence details, but that is minor given the simple operation.

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

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

The description is very concise and front-loaded. The core action is in the first sentence, the consequence in the second, and the parameter explanation is minimal and relevant. 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?

The tool is simple with one parameter and an output schema present. The description explains the essential behavior and parameter source. 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 0%, so the description must compensate. It does by explaining that 'name' is the cabinet to activate and pointing to sbis_list_cabinets as the source of valid values. This is sufficient for a single string parameter.

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

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

The description states a specific verb and resource: 'Switch the active cabinet' and explains the consequence. This clearly differentiates it from sibling tools like sbis_list_cabinets, sbis_add_cabinet, and sbis_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?

It gives clear context for when to use the tool: before making API calls with a different cabinet's credentials. It references sbis_list_cabinets for finding valid names, but does not explicitly discuss when not to use it or compare against 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?

Annotations already mark this as non-read-only and non-destructive, but the description adds important behavioral context: the confirm_write guard ('nothing is sent without it'), the target API URL, and the response shape (JSON success or error envelope). This goes beyond the structured annotations and no contradiction is present.

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 organized with a one-line purpose, target URL, critical guard, sibling routing, parameter roles, and return envelope. The Args section does add value because schema descriptions are absent. It could be trimmed slightly but is appropriately sized for a 5-parameter tool.

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

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

For a generic write dispatcher, the description covers the catalog lookup, placeholder substitution, query/body construction, confirmation flag, target API, and response envelope. It also routes edge cases to the correct sibling tools. Output schema exists, so return-value documentation is not needed, and no critical invocation detail 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 compensates by explaining the role of every parameter: operation_id comes from the catalog, path_values fill {placeholders}, query is query-string parameters, body is a JSON request body, and confirm_write must be true. It does not enumerate exact object shapes, but those are free-form by design.

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 action and resource: 'Execute one WRITE endpoint from the catalog: create or update data.' It also distinguishes itself from siblings by explicitly naming sbis_delete_method for irreversible operations and sbis_call_method for reads, so an agent can route correctly without opening sibling 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 says when to use this tool versus alternatives: irreversible operations go to sbis_delete_method, reads go to sbis_call_method, and this tool covers create/update writes. It also states the precondition confirm_write=true and points to sbis_search_methods for finding operation_id, giving clear selection and invocation 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?

Given annotations already declare readOnlyHint=false and openWorldHint=true, the description adds meaningful behavior: method restrictions, confirm_write guard, host default behavior, and the success/error envelope. It stops short of detailing overwrite consequences, idempotency, or authentication prerequisites, but it substantially expands on the 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 and the text is tight, but there is minor redundancy: 'POST, PUT and PATCH only' is restated in the Args line, and confirm_write is stated twice ('requires confirm_write=true' and 'confirm_write: must be true'). Still, the structure makes all required parameters easy to scan.

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 six-parameter raw write tool with no schema descriptions, the description covers every parameter, the invocation constraints, the target API documentation, and the response envelope. An agent has enough information to select and call 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 description coverage is 0%, and the description compensates thoroughly by explaining each parameter: method allowed values, path format (leading '/'), host override/default, query-string parameters, JSON body, and the mandatory confirm_write=true.

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 'Create or update data at ANY path, including paths not in the catalog,' which gives a specific verb, resource, and scope. This directly differentiates the raw tool from catalog-scoped siblings like sbis_write_method and sbis_call_method.

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 clearly states the supported methods and the confirm_write requirement, and the 'ANY path, including paths not in the catalog' phrase gives the selection context for raw writes. However, it does not explicitly name an alternative or say 'use sbis_write_method for catalog paths,' so the guidance is strong but not fully explicit.

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