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

With no annotations, the description carries the full behavioral burden, yet it says nothing about irreversibility, required permissions, or the fact that this is a destructive nested mutation. The preview/confirm behavior exists only in the schema, so the description adds almost no behavioral context.

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

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

The HTTP route is front-loaded and the tool's intent is short, but the trailing 'Тег: Конфигурация' and 'Спека: admin' lines are metadata noise that do not help an agent select or invoke 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?

For a destructive tool with no annotations and no output schema, the description is too thin: it does not explain the surprising requirement that 'value' is mandatory for a delete, nor any confirmation/permission prerequisites. An agent could easily construct a wrong call.

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

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

Schema description coverage is 100%, so key, value, and confirm are already documented in the schema. The description adds no syntax, format, or scoping detail beyond restating that a nested value/object is targeted, which is the baseline for full-coverage schemas.

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

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

The description names a specific verb (DELETE) and resource path (/admin/config/{key}) and clarifies it removes a value or object nested inside the config object. That distinguishes it from a top-level config delete at a high level, though it never addresses the by_key vs non-by_key sibling split.

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

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

There is no guidance on when to use this tool versus admin_config_delete, admin_config_put, or admin_config_by_key_post. The only routing signal is the implied HTTP method in the path, leaving the agent to infer the rest.

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

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

No annotations are provided, so the description carries full behavioral burden, yet it only says it's a GET. It doesn't disclose authentication/permission requirements for an admin endpoint, whether the returned object is a list or single object (odd given limit/offset params), or error behavior for nonexistent keys.

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 raw endpoint header plus Russian tag/spec metadata rather than agent-facing prose. There is no front-loaded summary sentence, and the 'Тег'/'Спека' lines are scaffolding that don't help tool selection.

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 an admin GET with three params, no annotations, and no output schema, the description should at least clarify the response shape and admin auth requirements. It instead repeats the endpoint and metadata, leaving the agent under-informed about a tool that appears to return a paginated structure.

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

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

Schema description coverage is 100%, so the schema already documents key, limit, and offset. The description adds no further parameter semantics, which is acceptable at baseline 3, though it notably never explains why a GET-by-key endpoint accepts limit/offset (suggesting a paginated collection), leaving a semantic gap.

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

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

The tool name itself is descriptive (admin_config_by_key_get), and 'Получить объект конфига' (Get config object) states a verb + resource, so purpose is recoverable. But the description is largely a raw HTTP endpoint dump (GET /admin/config/{key}) with autogenerated tags, and offers no differentiation from sibling admin_config_get or other config tools.

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

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

There is no when-to-use guidance at all – no indication of when the by_key variant should be chosen over admin_config_get, or what a 'key' represents in this config model. The agent is left to infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only signals a mutating POST/change action and does not disclose permission needs, overwrite/reversibility behavior, or that confirm:true controls whether a preview is returned in rw mode.

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

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

The description is short and front-loads the HTTP method/path and the action, but it includes boilerplate tag/spec labels that do not help an agent invoke the tool. It is concise but not maximally clean or informative.

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

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

For a mutation tool with no annotations, a nested request body, and multiple config-operation siblings, the description is too thin. It omits usage context, sibling differentiation, and behavioral details, leaving the schema to cover most operational 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?

Schema description coverage is 100%, so the schema already documents key, body, and confirm semantics. The description adds no additional parameter meaning beyond what is already in the structured input schema, making 3 the appropriate baseline.

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

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

The description states a specific action (change a config object) and the keyed resource (/admin/config/{key}), so the basic purpose is clear. However, it does not distinguish this POST operation from close siblings such as admin_config_put, admin_config_post, or admin_config_by_key_delete.

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

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

There is no guidance on when to use this tool versus the many sibling config tools, nor any conditions, alternatives, or exclusions. The tag and spec labels are metadata rather than 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?

No annotations are provided, so the description carries the full burden. It does not disclose side effects, required permissions, reversibility, or the preview behavior mentioned only in the schema for the 'confirm' parameter. The Russian snippet 'Удалить объект в конфиге' adds little beyond the obvious DELETE semantics.

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

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

The description is very short, but it is a mix of an HTTP route, a non-English sentence, and tags/spec metadata that are not useful for tool selection. It lacks front-loaded purpose clarity and mixes languages, reducing conciseness's 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 mutation tool with no annotations and no output schema, the description is inadequate. It does not explain what object is deleted, the impact of deletion, or the role of the 'confirm' parameter beyond what the schema already states. An agent would need to infer usage from the name alone.

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

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

Schema description coverage is 100%, so the schema fully documents the 'key' parameter ('ключ') and the 'confirm' parameter with its preview behavior. The description adds no additional parameter meaning, so the baseline of 3 is appropriate.

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

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

The description mostly restates the tool name with the HTTP method and route (DELETE /admin/config) plus a short non-English line 'Удалить объект в конфиге' (delete an object in the config). It does not distinguish this tool from the many siblings like admin_config_by_key_delete or admin_config_put. It is minimally informative beyond 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?

There is no guidance on when to use this tool versus alternatives. The sibling admin_config_by_key_delete and other config endpoints exist, but the description never mentions when this endpoint applies (e.g., deleting by key vs by ID) or any prerequisites. No when-to-use or when-not-to-use information is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the HTTP verb. It doesn't say whether results are paginated (despite limit/offset params), whether it requires admin auth, or what the response shape is. For a read endpoint the safety profile is at least implied by GET, but little else is given.

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

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

It is short and front-loaded with the endpoint and a one-line gloss, which is good. But the 'Tag' and 'Spec' lines are filler metadata that don't help an agent decide or invoke, and the description is arguably under-specified rather than tight.

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

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

With no annotations, no output schema, and a sibling that fetches individual keys, the description should clarify the full-config scope, auth expectations, and pagination behavior but does none of these. It's insufficient for guiding correct selection and invocation among the admin_config_* family.

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

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

Schema description coverage is 100%, so both limit and offset are already documented in the schema with their defaults and meanings. The description adds no parameter meaning beyond this, which matches the baseline of 3 when the schema does the heavy lifting.

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 'GET /admin/config' with the Russian gloss 'Прочитать весь конфиг' ('read the entire config'), giving a clear verb+resource. However it does nothing to distinguish itself from siblings like admin_config_by_key_get, and the tag/spec lines are metadata rather than purpose. It's adequate but not sharply 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?

There is no explicit guidance on when to use this versus admin_config_by_key_get, which is the obvious alternative for fetching a single key instead of the whole config. The agent must infer from the name alone that this returns the full config rather than one entry.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing behavioral: no mention of the confirm:true gate, the rw-mode preview return, permissions, or mutation side effects. The confirm-preview behavior is documented only in the schema, not the description, so the description adds no behavioral value.

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

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

The text is short but is a raw OpenAPI dump (verb+path, one-line gloss, tag, spec name) rather than a front-loaded purpose statement. It is under-specified rather than concise.

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 config-mutating tool embedded in a large family of near-identical admin_config_* siblings, with no annotations and no output schema, the description should explain the mutation scope, the confirm/rw preview behavior, and its distinction from siblings. It does none of these.

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

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

Schema description coverage is 100%, so the nested body (key/value) and the confirm flag with its rw-mode preview semantics are already fully documented in the schema. Baseline 3 applies; the description adds nothing beyond it.

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

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

The description gives a specific HTTP verb and path ('POST /admin/config') and a Russian gloss ('Изменить объект в конфиге' — modify an object in the config), so the resource and mutation intent are identifiable. But it doesn't distinguish this tool from the many sibling config tools (admin_config_get/put/delete, admin_config_by_key_post, etc.), leaving the agent to infer scope from names alone.

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 statement of when to use this versus admin_config_put, admin_config_by_key_post, or admin_config_delete. The tag 'Конфигурация' and spec 'admin' are just routing metadata, not 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?

No annotations are provided, so the description must carry the burden, and it largely fails: it does not state that this is a mutation, the preview-without-confirm behavior (that lives only in the parameter description), or permission requirements. It does at least reveal the write semantics through 'Создать объект', but that is thin for a config mutation.

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

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

It is short, but that brevity is under-specification rather than efficiency. The route line, the tag and the spec line are boilerplate metadata rather than front-loaded 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?

For a config mutation tool with no annotations and no output schema, the description should explain the mutation's effect, the confirm/preview contract, and its relationship to the sibling post/put/delete tools. None of that is present; only the schema's confirm parameter implies the write guard.

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

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

Schema description coverage is 100%, so both parameters (body, confirm) are documented in the schema with meaningful titles/descriptions. The description adds nothing beyond the schema, but per the rubric the baseline is 3 when the schema does the heavy lifting.

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

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

The description is mostly a raw HTTP route ('PUT /admin/config') plus a terse Russian phrase 'Создать объект в конфиге' (create an object in the config). It names the resource but the verb is muddled — a PUT reportedly creates, and the sibling admin_config_post also exists, so the agent cannot tell which method actually creates. No meaningful differentiation from siblings.

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

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

There is no when-to-use guidance. The only hint is the 'confirm' parameter in the schema, which implies this is a non-GET (write) operation and returns a preview without confirm:true. The description itself offers no routing between admin_config_get/post/put/delete.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses nothing beyond the raw HTTP verb: no statement of what is destructively removed, whether the deletion is reversible, required permissions, or side effects on related records. The one behavioral detail (confirm:true and preview mode) is documented in the schema, not here.

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

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

The text is short and front-loads the endpoint, but it includes metadata boilerplate ('Тег: Промокоды', 'Спека: admin') that provides no invocation value. It is terse rather than meaningfully concise.

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

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

This is a destructive delete operation with no annotations and no output schema, so the description should explain the destructive scope and the confirm-gated preview behavior. Instead it offers only the endpoint and a translation of the name, leaving an agent under-informed for a high-impact mutation.

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

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

Schema description coverage is 100%, so both parameters (id, confirm) are already fully documented in the schema. The description adds no additional meaning, making the baseline of 3 appropriate.

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

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

The description gives DELETE /admin/promo and the Russian phrase 'Удалить промокод' (delete promo code), which states a verb and resource. However, this essentially restates the tool name and does not differentiate the tool from its DELETE/GET/POST/PUT promo siblings beyond what the name already conveys.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., admin_promo_get, admin_promo_put), nor any mention of prerequisites. The only usage hint, the confirm/preview mechanism, lives in the schema rather than the description.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the endpoint and a tag/spec label. It says nothing about authentication/authorization requirements, whether results are paginated, default sorting, or what fields are returned.

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

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

The text is short and front-loaded with the endpoint, but 'Тег: Промокоды' and 'Спека: admin' are internal metadata that add little for an agent deciding how to call the tool. It is compact but not maximally informative per line.

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

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

With no annotations and no output schema, the description should explain that this is an admin-scoped read returning promo codes and how the filters behave. Instead it is effectively a raw endpoint stub, leaving substantial gaps for a multi-parameter admin endpoint.

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

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

Schema description coverage is 100%, with limit, offset, and user_id all documented in the schema, so the baseline is 3. The description adds no meaning beyond the schema (e.g., how user_id filters the list), so it neither helps nor hurts.

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

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

The description gives the HTTP verb and path (GET /admin/promo) plus a Russian gloss 'Список промокодов' (list of promo codes), so the operation is identifiable as a listing endpoint. However, it offers no differentiation from the many sibling promo/catalog endpoints (admin_promo_post/put/delete, user_promo_get), so the agent must infer the distinction.

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

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

There is no statement of when to use this listing endpoint versus alternatives such as admin_promo_post or user_promo_get, and no mention of prerequisites, filters, or pagination expectations. Usage must be inferred entirely from the name and HTTP verb.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: no statement of side effects, required permissions, reversibility, or the fact that the write is previewed unless confirm is set. The 'Тег'/'Спека' lines are internal routing metadata, not behavioral context.

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

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

The text is short but under-specified rather than economical: it is a raw route string plus 'Тег'/'Спека' internal labels, with the actual purpose buried in a single verb phrase. Nothing is front-loaded for an agent's decision.

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

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

This is a mutation endpoint with a nested request body, no output schema, and no annotations, so the description should do more work. It omits what fields are modified, the POST-vs-PUT distinction, and the confirm/preview workflow, leaving the definition inadequate 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 100% (the body and confirm fields are documented in the schema, including the confirm-preview behavior), so the baseline is 3. The description adds no additional meaning about the mutable promo fields or the confirm flag.

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

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

The description names a resource (промокоды / promo codes) and an action ('Изменить промокод' = modify a promo code), plus the HTTP route, so the target is identifiable. However, it does not distinguish itself from its siblings admin_promo_get/put/delete; with a PUT and DELETE present, calling POST 'modify' leaves the create-vs-update semantics ambiguous.

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

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

There is no guidance on when to use this tool versus the sibling admin_promo_put (update), admin_promo_delete, or the read-only admin_promo_get. The agent must infer the intended operation from the HTTP verb alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no statement about permissions, idempotency, side effects, or what 'generation' produces. The useful behavioral detail that lives in the schema ('confirm' triggers preview in rw mode) is not echoed or expanded in the description, and the description makes no mention of the mutation semantics a PUT implies.

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

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

It is short, but most of its lines are metadata noise (raw HTTP method/path, 'Тег', 'Спека') rather than front-loaded substance, and the one sentence with any content is ambiguous. Brevity here comes from under-specification, not from efficient editing.

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 takes a nested body object with eight documented fields and a confirmation flag, has no output schema, and has no annotations, so the description is the only place behavioral and usage context could live. It supplies none of that, leaving an agent unable to safely construct a call or predict the result.

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

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

Schema description coverage is 100%, including titles for the eight nested body fields and a behavioral note on 'confirm', so the schema already does the heavy lifting. The description adds no parameter meaning beyond the vague phrase 'Генерация промокодов', which does not explain any field semantics, so the baseline 3 applies.

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

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

The description largely restates the tool name ('PUT /admin/promo') and pads it with tag/spec labels ('Тег: Промокоды', 'Спека: admin') that convey no task meaning. 'Генерация промокодов' hints at promo-code handling, but it conflicts with the PUT verb the name implies (generate vs. replace/update), so an agent cannot tell what this call actually does or how it differs from admin_promo_post/get/delete.

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

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

There is no when-to-use guidance at all: no prerequisites, no conditions, and no mention of the sibling promo tools (admin_promo_get/post/delete, user_promo_get, user_promo_apply_by_code_get) that a caller would need to choose between. Nothing in the text helps an agent decide whether to invoke this rather than another promo endpoint.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It never says the operation is destructive or irreversible, whether it cascades to identities/groups, or what permissions are required. The only behavioral hint (rw-mode preview requiring confirm:true) lives in the schema, not the description.

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

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

It is short, but it wastes its few lines on metadata ("Тег: Сервера", "Спека: admin") that adds no value for an agent. Front-loading the HTTP verb is reasonable but the content is thinner than the brevity suggests.

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

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

For a destructive delete with no annotations and no output schema, the description should at minimum warn about irreversibility and confirmation requirements. None of that context is present in the description text.

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

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

Schema description coverage is 100%: server_id is documented as the server id and confirm as the explicit-confirmation/preview toggle. The description adds nothing beyond that, so the baseline of 3 applies.

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

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

"Удалить сервер" states a clear verb+resource, so the agent knows this removes a server. However, the phrasing is a raw OpenAPI spec dump (HTTP method + path + tag + spec name) that largely restates the tool name, and it draws no line between this tool and the many sibling deleters such as admin_server_identity_delete or admin_server_group_delete.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternative admin_server_get / admin_server_put / admin_server_post endpoints this pairs with. The agent must infer everything about selection from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. The 'GET' prefix implies a read, but nothing is said about permissions required, pagination behavior, default limits, or what the returned server records contain.

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

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

The text is short but is not a coherent description; it is four disconnected fragments. The 'Тег' and 'Спека' lines are internal routing metadata that do not help an agent decide or invoke, so they fail the 'every sentence earns its place' test.

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

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

This is a simple read-only list endpoint with zero required parameters, 100% schema coverage, and no nested objects, so the low description burden is partially justified. Still, no exclusions or sibling routing are given, leaving the agent to guess among many similarly-named admin_server tools.

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

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

Schema description coverage is 100% – both 'limit' and 'offset' are documented in the schema with defaults and minimums – so the baseline of 3 applies. The description adds no additional semantics beyond what the schema already conveys.

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

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

The line 'Получить список серверов' does state a specific verb and resource (list servers), so the purpose is recoverable. However it is embedded in a raw HTTP endpoint dump alongside tag/spec metadata, and there is no differentiation from the many sibling server tools (admin_server_post/put/delete, admin_server_group_get, admin_server_identity_get).

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

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

There is no guidance on when to use this tool versus the sibling server endpoints. The 'admin' spec and 'Сервера' tag hints at an admin-scoped listing, but no conditions, prerequisites, or alternatives are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing: it does not state that the operation is irreversible, what happens to servers still assigned to the group, or what permissions are required. 'Удалить' is the only signal that this is a destructive write, and the useful confirm/preview semantics live only in the schema.

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

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

It is short and front-loads the endpoint and action, but the trailing 'Тег' and 'Спека' lines are generator boilerplate that convey nothing an agent needs. Roughly half the text is noise.

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

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

For a destructive admin mutation with no annotations and no output schema, the description should at minimum flag irreversibility and side effects on dependent servers. The schema covers the inputs, but the behavioral picture is left almost entirely blank.

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

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

Schema description coverage is 100%, so both group_id and the confirm/preview behavior are already fully documented in the schema. The description adds no parameter meaning beyond that, which is the baseline 3 case.

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

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

The description names a specific verb and resource ('Удалить группу серверов' / DELETE /admin/server/group), so an agent knows exactly what the tool does. It does not, however, distinguish itself from the sibling admin_server_group_get/post/put beyond the HTTP 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?

There is no when-to-use guidance, no mention of prerequisites or alternatives among the sibling group tools, and no reference to the confirmation workflow. The agent must infer usage entirely from the name and path.

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

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

No annotations are provided, so the description carries the full burden. It restates the HTTP path and a Russian one-liner but discloses nothing about auth requirements, pagination behavior (only implied by limit/offset params), whether results are paginated or truncated, or what the response contains. The tag/spec metadata is not behavioral context.

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

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

Very short and front-loaded with the HTTP path, but two of the four lines ('Тег: Группы серверов', 'Спека: admin') are catalog metadata that do not help an agent decide or invoke. The useful content is a single line, making the entry mixed-language and partly 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 simple admin list endpoint with full schema coverage and no output schema, the description is minimally adequate — the agent knows it's a list operation. However, nothing is said about admin auth requirements or the paginated nature of the result, which an agent calling this endpoint would benefit from knowing.

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

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

Schema description coverage is 100% — limit and offset are both documented with Russian descriptions and defaults. The description adds no syntax, ordering, or default-value detail beyond the schema, so the baseline 3 for high coverage is appropriate.

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

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

The description states a specific verb and resource: 'GET /admin/server/group' paired with 'Получить список групп серверов' (get list of server groups). This is unambiguous about what the tool returns, though it does not differentiate itself from sibling variants like admin_server_group_post/put/delete or admin_server_get beyond the implicit GET=read/list convention.

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

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

No when-to-use guidance is given. There is no statement of prerequisites, no mention of when to prefer this over admin_server_group_post/put/delete, and no scope conditions. The 'Спека: admin' line hints at admin scope but does not constitute usage direction.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it delivers almost nothing: the HTTP method implies a mutation, but permissions, reversibility, the group_id-as-upsert behavior, and the rw-mode preview flow are all unmentioned. Metadata lines ('Тег', 'Спека') add no behavioral context.

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

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

It is short and front-loads the method, but two of the four lines are low-value scaffolding (route duplication, tag, spec) rather than information an agent needs. Acceptable size with some waste.

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

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

For a mutation endpoint with a nested body, no annotations, and no output schema, the description omits everything an agent would need: what a successful call returns, whether it requires confirm:true, and how it relates to the sibling PUT/GET/DELETE group tools.

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

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

Schema description coverage is 100% — the body fields (name, type, group_id, settings, transport) and the confirm flag all carry titles/descriptions. The description adds no syntax or format detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description restates the endpoint ('POST /admin/server/group') and gives a vague verb+resource ('Изменить группу серверов' / change server group). It does not distinguish this tool from its obvious sibling admin_server_group_put (update) or admin_server_group_post's likely create semantics, so an agent cannot tell whether this creates or mutates a group.

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

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

There is no when-to-use guidance, no prerequisite conditions, and no reference to any alternative (e.g., PUT/DELETE on the same resource). The 'Тег' and 'Спека' lines are taxonomy metadata, not 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?

No annotations are supplied, so the description carries the full burden of behavioral disclosure. It states only that the operation creates a server group; it does not describe auth/role requirements, reversibility, side effects on existing groups, or the confirm-gated preview behavior that is central to this write tool. Only the bare mutation implication is conveyed.

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

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

The description is short and the purpose is present in the second line. The first line ('PUT /admin/server/group') largely duplicates the tool name, and the tag/spec lines are internal metadata, but nothing is verbose or padded.

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

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

For a mutation tool with a nested request body, no annotations, and no output schema, the description is far too thin. It omits the confirmation/preview semantics, permission expectations, and effects, leaving the agent to infer essential write behavior from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents the request body fields (name, type, group_id, settings, transport) and the confirm flag. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource ('PUT /admin/server/group', 'Создать группу серверов' = create a server group), so the intent is unambiguous. However, it offers no differentiation from the many sibling server/group tools (e.g. admin_server_group_post, admin_server_group_get/delete), which is the bar for a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as admin_server_group_post or admin_server_group_get/delete. The only routing hint is the raw tag ('Группы серверов') and spec name, which are internal metadata rather than agent-facing 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?

No annotations are provided, so the description carries the full burden. The vital behavioral detail — that without confirm:true in rw mode a request preview is returned instead of executing the deletion — is disclosed, but only in the schema, not the description, and the description does not state irreversibility, required permissions, or scope of what is destroyed.

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?

Four short lines are not bloated, but the description is not front-loaded: the method/path and Russian gloss come first, and the useful part is absent entirely, with 'Тег'/'Спека' metadata consuming space without adding call guidance.

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 destructive tool with no annotations and no output schema, the description omits the confirmation semantics that govern whether the operation actually runs. Because the schema covers both parameters at 100%, the definition is minimally viable but not 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 100%: both 'id' ('id ключа') and 'confirm' (preview semantics) are documented in the schema. The description adds nothing about parameters beyond the endpoint path, so the baseline 3 applies.

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

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

States a specific verb (DELETE) and resource (SSH key under /admin/server/identity), and the Russian gloss 'Удалить SSH ключ' confirms the resource. It is distinguishable from sibling admin_server_identity_get/post/put by the HTTP verb, though the description relies on the raw endpoint rather than describing intent.

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

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

There is no statement of when to use this tool versus admin_server_identity_put or the generate/get siblings, and no prerequisites. The 'Тег: Ключи SSH / Спека: admin' lines are metadata, not 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?

No annotations are provided, so the description carries the full burden. It never says that a GET-shaped call has a generating side effect, whether admin privileges are required, whether existing keys are replaced, or whether the operation is idempotent. A key-generating mutation disclosed only by its path is materially under-specified.

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

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

It is short, but 'Тег: Ключи SSH' and 'Спека: admin' are generator boilerplate that earn no place, and the actual intent is buried after the raw route. The informative sentence is not 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 no annotations, no output schema, and an undeclared side effect, the definition leaves the agent unable to predict the result of the call. For a mutation-class tool this should say considerably more.

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

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

Schema coverage is 100%, so limit/offset are already documented in the schema. The description adds nothing about them, and notably does not explain what pagination means for a key-generation endpoint — but the baseline of 3 applies when the schema does the work.

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 Russian line 'Сгенерировать SSH ключи' does state the purpose — generate SSH keys — but the rest is an auto-generated restatement of the HTTP route, tag, and spec. Nothing distinguishes it from siblings like admin_server_identity_post or admin_server_identity_put, which plausibly also create identity material.

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

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

No when-to-use, prerequisites, or alternative is given. An agent has no basis for choosing this over admin_server_identity_post/get/delete; the only implicit signal is the word 'generate'.

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

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

No annotations are provided, so the description carries full burden. It implies a read operation via GET, but discloses nothing about pagination defaults, permissions required, auth scope, or whether the list is workspace-scoped. The Russian phrase confirms the subject (SSH keys) but adds no behavioral context beyond the endpoint.

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

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

Extremely brief, four short fragments with no filler. Front-loading is fine. It is not padded, though its brevity comes at the cost of content rather than being earned conciseness.

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 an admin-prefixed read tool with two paginated params and no output schema, the description is incomplete. It doesn't state what a returned SSH key record looks like, pagination behavior, or auth requirements, and offers no differentiation from the numerous admin_server_identity_* siblings.

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

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

Schema description coverage is 100% — both limit and offset are documented in Russian in the schema itself. The description adds nothing about pagination semantics or defaults. Baseline 3 applies when the schema does the heavy lifting.

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 consists of a raw HTTP route ("GET /admin/server/identity"), a Russian tagline ("Список SSH ключей"), a tag, and a spec reference. The GET+SSH-keys combination conveys a read list operation, but it's presented as an endpoint dump rather than a tool description. It doesn't differentiate meaningfully from siblings like admin_server_identity_get vs admin_server_identity_generate_get other than via the raw path.

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

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

No when-to-use, when-not-to-use, or alternative-selection guidance is given. The tag "Ключи SSH" and spec "admin" are metadata, not usage direction. An agent gets no signal about when this list endpoint should be preferred over, e.g., admin_server_identity_generate_get.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the HTTP method. It does not mention that non-GET calls require confirm:true, what happens in preview mode, or which fields (e.g. private_key) are sensitive. The mutation semantics are only implied by 'Изменить'.

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 payload is four fragmentary lines, three of which (the raw path, the tag, the spec) restate tooling metadata rather than user-facing meaning. It is short but not front-loaded around what an agent needs to decide or act; the route line leads instead of the purpose.

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

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

This is a write operation with a nested body including a private key, zero annotations, and no output schema, so the description should explain confirmation behavior, permissions, and side effects. Instead it is a bare endpoint stub, leaving significant gaps for such a 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?

Schema description coverage is 100% and each body field carries a Russian title, so the schema already documents id, name, public_key, fingerprint, private_key, and the confirm flag. The description adds nothing beyond that, but the baseline is 3 when the schema does the explaining.

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 phrase 'Изменить SSH ключ' (modify SSH key) gives a specific verb and resource, and the tool is identifiable against most siblings. However it does not distinguish itself from the sibling admin_server_identity_put, which presumably also modifies an identity, so sibling differentiation is incomplete.

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

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

There is no guidance on when this tool applies versus admin_server_identity_put, admin_server_identity_delete, or admin_server_identity_generate_get. The 'Тег' and 'Спека' lines are metadata labels, not usage conditions, so the agent must infer context entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose that confirm:true may be required (the schema mentions this), doesn't describe whether this replaces or appends keys, doesn't mention permissions or side effects, and doesn't explain the preview mode referenced in the schema. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is three short lines: the HTTP method/path, a purpose statement, a tag, and a spec reference. It's front-loaded but includes some metadata (Тег, Спека) that may be less useful. No excessive verbosity, but not purely focused on the action either.

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

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

For a mutation tool with no annotations, no output schema, and a nested body object, the description is too thin. It doesn't explain the confirm parameter's role (only the schema does), doesn't cover return values, and doesn't distinguish from admin_server_identity_post. An agent would need to infer a lot from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, including the body fields and the confirm flag. The description adds no parameter-level detail beyond what's in the schema, but baseline 3 is appropriate when schema does the heavy lifting.

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: 'Сохранить новый SSH ключ' (Save a new SSH key) on PUT /admin/server/identity. It's clear what the tool does, and the sibling set includes admin_server_identity_post/get/delete/generate_get, so identity-context is shared. It doesn't explicitly differentiate from admin_server_identity_post (which likely creates vs. replaces), leaving some ambiguity.

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

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

No guidance on when to use PUT vs POST (admin_server_identity_post) or when not to use it. The description only says 'save a new SSH key' with no prerequisites or alternatives mentioned.

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

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

No annotations are provided, so the description carries full behavioral burden. It reveals nothing about permissions, side effects, whether missing fields are nulled, or return behavior. The one genuinely useful behavioral fact, the confirm:true / rw-preview gating, lives in the schema rather than the description.

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

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

The description is terse but for the wrong reason: it is raw route metadata and a tag/spec line rather than a front-loaded explanation. It omits the one useful thing an agent needs (the confirm gate) while including boilerplate like 'Тег: Сервера' and 'Спека: admin'.

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

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

For a mutation endpoint with a nested body, zero annotations, and no output schema, the description is far too thin. It leaves the agent without the required confirmation semantics, scope, or effect of the call, all of which are essential 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?

Schema description coverage is 100%, with each body field titled and some described, so the schema does the heavy lifting. The description adds no parameter meaning beyond the schema, but with full coverage the baseline of 3 applies.

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

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

The description is essentially the raw HTTP route and Russian metadata ('POST /admin/server', 'Изменить сервер') rather than a natural-language statement of purpose. An agent can infer it modifies a server from 'Изменить сервер', but the tool name says 'post' while the description says 'edit', and it never states what a server record represents or how it differs from admin_server_put or admin_server_get siblings.

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

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

No guidance on when to use this tool versus admin_server_put, admin_server_get, or admin_server_delete. The only usage hint comes from the schema's 'confirm' field, not the description. Nothing routes the agent among the many admin_server_* 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?

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about permissions, side effects, reversibility, or the preview behavior that the schema's 'confirm' field implies. The only behavioral hint is the implicit mutation from 'PUT'/'Создать'.

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

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

It is short and the purpose appears early, but several lines (raw path, 'Тег: Сервера', 'Спека: admin') are generated boilerplate that consumes space without informing the agent.

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 create operation on a nested-object resource with no annotations and no output schema, the description is far too thin. It omits the meaning of the PUT method choice, required fields, and the confirm/preview workflow that an agent needs to call it correctly.

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

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

Schema coverage is 100% (nested body properties and the confirm field are documented in the schema), so the baseline of 3 applies. The description adds no parameter meaning beyond what the schema already provides.

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

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

The line 'Создать сервер' (create server) states a verb and resource, so the basic purpose is discernible. However there is no differentiation from siblings like admin_server_post, admin_server_get, or admin_server_delete, and the rest of the text is auto-generated noise (HTTP method, tag, spec name) that adds no clarifying 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 offers no when-to-use guidance, no prerequisites, and no indication of how this differs from the sibling admin_server_post or admin_server_get. An agent must infer usage entirely from the name and method.

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

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

No annotations are provided, so the description carries the full burden. The 'GET' prefix implies read-only and the schema defaults hint at pagination, but nothing states auth requirements, whether results are paged, maximum page size, or what the response contains.

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

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

It is short and front-loads the endpoint, but 'Тег: Услуги' and 'Спека: admin' are generator metadata that add no selection value to an agent. It is terse without being informative.

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

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

With no annotations and no output schema, the description should at least characterize the returned collection and any filtering behavior. Instead it supplies only the raw route and a category label, leaving an agent to infer everything about the call's semantics.

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

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

Schema description coverage is 100%, with limit, offset and service_id each documented in the schema itself (including defaults and minimums). The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

The text 'GET /admin/service/children' plus 'Список дочерних услуг' (list of child services) does identify a verb and resource, so the core purpose is recoverable. However it reads as a raw endpoint dump rather than a written description, and it does nothing to distinguish itself from the sibling admin_service_children_post or admin_service_get.

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

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

There is no guidance on when to call this versus the sibling admin_service_children_post, admin_service_get, or admin_user_service_categories_get. The endpoint path implies 'children of a service' but the description never states a use condition or prerequisite.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: it does not say whether this replaces the entire child-service list or appends, what permissions are required, or what the effect on existing children is. It also never mentions the confirm/preview behavior that the schema documents, leaving the agent to infer mutation semantics from the verb alone.

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

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

It is short, but a meaningful share of the text is spec noise ('Тег: Услуги', 'Спека: admin') and a restatement of the route that adds nothing. The purpose sentence is present but not especially front-loaded or expanded.

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

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

For a mutation endpoint with no annotations, no output schema, and a nested request body, the description is too thin. It omits destructive/merge semantics, auth requirements, and the confirmation workflow, leaving an agent unable to call it safely without reading the schema closely.

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

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

Schema description coverage is 100% and the schema already documents both the body and confirm parameters, so the baseline is 3. The description adds no parameter meaning beyond the schema; notably the nested 'children' object has no inner properties defined, and the description does not compensate for that.

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 pairs the HTTP verb and route (POST /admin/service/children) with the Russian phrase 'Изменить список дочерних услуг' (change the list of child services), so the resource and mutation intent are identifiable. However, it does little to distinguish this from the sibling admin_service_children_get or admin_service_put, and the 'Тег'/'Спека' lines are raw spec metadata rather than 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?

There is no statement of when to use this tool versus alternatives such as admin_service_children_get (read) or admin_service_put, nor any prerequisites or context. The only implicit cue is the POST verb itself.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the HTTP verb. It does not state that deletion is destructive/irreversible, what happens to dependent entities (children/orders), or permission requirements. The confirm behavior is documented in the schema, not the description, so the description adds little.

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

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

It is short and front-loads the method and path, which is good. But the 'Тег: Услуги' and 'Спека: admin' lines are generator metadata rather than agent-useful content, diluting an already minimal payload.

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

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

For a destructive mutation with no annotations and no output schema, the description should explain effects and irreversibility. It leaves the agent to infer everything about consequences from the method name, which is inadequate for a delete operation.

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

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

Schema description coverage is 100%: service_id ('id услуги') and the confirm flag (explicit confirmation; without confirm:true in rw mode a preview is returned) are both well documented in the schema. The description adds no parameter semantics of its own, so the baseline 3 applies.

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

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

The description states a specific verb and resource: DELETE on /admin/service, glossed as 'Удалить услугу' (delete service). That is unambiguous. However, it offers no differentiation from the many other delete siblings (admin_user_service_delete, user_service_delete, admin_service_event_delete), so an agent must infer scope from the path alone.

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

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

There is no when-to-use guidance, no preconditions, no mention of the confirm workflow, and no routing to alternatives. The HTTP method and path imply usage, but nothing tells the agent when this is the correct tool versus the other service/user-service deletes.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it delivers almost nothing: it does not say whether the deletion is permanent, what permissions are required, what happens to related service records, or what is returned on success. The only behavioral hint is the raw 'DELETE' verb, while the useful confirm/preview behavior lives in the schema's parameter description, not here.

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

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

It is short and leads with the method and path, which is the most useful information. But the 'Тег: События' and 'Спека: admin' fragments are internal spec metadata that consume space without helping an agent decide or invoke.

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

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

For a destructive admin operation with no annotations and no output schema, the description is too thin: it omits irreversibility, authorization expectations, and failure modes. The confirm-parameter semantics are the only mitigating factor, and those come from the schema, not the description.

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

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

Schema description coverage is 100%, with both 'id' and 'confirm' documented in the schema itself, so the schema does the heavy lifting. The description adds no parameter meaning beyond that, which lands at the baseline 3 for high-coverage schemas.

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 pairs a specific HTTP verb (DELETE) with a resource path (/admin/service/event) and a Russian gloss ('Удалить событие'), so the basic operation is identifiable. However, it does nothing to separate this tool from the crowded set of admin_service_event_get/post/put siblings or admin_service_delete, and the 'Тег'/'Спека' lines are generator boilerplate rather than meaning.

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

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

There is no statement of when to use this tool versus admin_service_event_put, admin_service_delete, or any of the other delete variants in the sibling list. The only context is the endpoint path itself, which the agent would have to infer from.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing. The 'GET' prefix implies a safe read, but there is no mention of pagination behavior, permissions/admin scope, sort order, or what an event record contains.

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

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

It is short and front-loaded with the endpoint path, with no filler sentences. However, this brevity comes from omission rather than efficiency — the tag/spec lines add nothing an agent can act on, and the definition is too thin to be genuinely concise-and-complete.

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

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

For a list endpoint with no output schema and no annotations, the description should explain what a returned event is, whether results are paginated/capped, and who may call it. None of that is present, so an agent cannot confidently invoke it beyond firing a bare GET.

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

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

Schema description coverage is 100%: both limit and offset are documented in the schema (max records, offset skipping). The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

The description states a specific verb+resource ('GET /admin/service/event', 'Список событий' = list of events), which is better than a tautology. But it does nothing to distinguish this from siblings such as admin_service_event_post/put/delete or admin_service_order_get; the only differentiators are the raw HTTP path and the tag 'События', which the agent must parse itself.

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

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

There is no guidance on when to use this read endpoint instead of the sibling write variants or the many other admin_*_get endpoints. The 'Тег' and 'Спека' lines are documentation metadata, not usage guidance, so the agent gets no context signal about selecting this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about permissions, reversibility, or side effects. Only the HTTP verb hints that this mutates state. Notably, the schema's `confirm` parameter documents a preview-vs-execute mode that the description never surfaces.

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

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

It is short, but what content exists is a metadata dump (HTTP path, tag, spec) rather than meaningful guidance. This is under-specification dressed as brevity rather than economical communication.

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

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

For a mutation tool with a nested request body, an enum-bearing `name` field, no output schema, and no annotations, this description is far too thin. It should at minimum distinguish POST from PUT and explain the confirm-based preview behavior.

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

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

Schema description coverage is 100%, so both the `body` and `confirm` parameters are already documented in-schema. The description adds no syntax, format, or field-level meaning beyond that, which is the baseline 3 case.

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 pairs a verb and resource ("Изменить событие" = change event) with the raw endpoint POST /admin/service/event. It states what the tool touches, but gives no differentiation from the equally-plausible siblings admin_service_event_put and admin_service_event_delete, so an agent cannot tell POST from PUT here.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives despite a huge sibling set that includes admin_service_event_get/put/delete. The 'Тег/Спека' lines are taxonomy labels, not usage instructions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a mutation via 'create', but fails to mention the explicit confirm requirement, the preview mode in rw, idempotency, or any side effects, all of which are essential for a non-GET 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 text is short but includes boilerplate metadata ('PUT /admin/service/event', 'Тег: События', 'Спека: admin') that does not help an agent invoke the tool. The useful part ('Создать событие') is buried after the method/path, so it is not front-loaded effectively.

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 a nested request body, an enum parameter, and a critical confirm parameter, and no output schema, the description is far too thin. It omits any explanation of the confirm mechanism, the preview behavior, or when the operation is appropriate, leaving the agent without enough context to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including the confirm behavior. The description adds no additional meaning beyond restating the operation, matching the baseline of 3 for high schema coverage.

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

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

States a specific verb+resource: 'Создать событие' (create event) plus the HTTP method and path. The purpose is clear, but it does not differentiate from sibling admin_service_event_post, which likely also creates events, so it lacks 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?

Provides no guidance on when to use this tool versus alternatives such as admin_service_event_post or other event operations. The description is purely declarative with no context 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?

No annotations are provided, so the description carries the full burden, yet it discloses almost nothing beyond the HTTP verb 'GET' implying a read-only fetch. It omits auth/permission requirements, pagination semantics, default result size, and what the response contains.

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

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

It is short, but it is a raw scraped-fragment dump rather than a front-loaded statement of purpose; the tag and spec tokens are noise that consumes the little content budget there is.

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 collection-list tool with zero required parameters and no output schema, the description should at least state that it returns a paginated set of service records and what those records represent. None of that is present, leaving an agent unable to predict the result.

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

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

Schema description coverage is 100% — both limit and offset have inline descriptions — so the schema does the heavy lifting. The description adds no meaning beyond that (e.g., whether limit/offset are advisory, max limits, or how ties are broken), which matches the baseline 3.

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

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

The description is essentially the tool name rendered as an HTTP path plus a Russian gloss ('GET /admin/service', 'Получить услугу'), which restates the identifier rather than explaining the resource. It never says that this returns a *list* of services (implied only by the limit/offset params) nor how it differs from siblings like admin_service_children_get or admin_service_order_get.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. The 'Тег: Услуги / Спека: admin' fragments are source-doc metadata, not instructions for selecting this tool over admin_service_post/put/delete or any other sibling.

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

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

No annotations are provided, so the description carries the full disclosure burden. The 'GET' prefix implies a read, but nothing is said about authentication requirements, result volume, or pagination behavior, and the surrounding tag/spec lines add no behavioral context.

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

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

The text is short but structured as a raw endpoint dump: a method/path, a purpose line, then 'Тег: Услуги' and 'Спека: admin'. The tag and spec lines carry no meaning for an agent selecting or invoking the tool, so they fail to earn their 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 read-only list endpoint with no annotations and no output schema, the description should say more about what is returned, whether the list is paginated, and any access restrictions. As written it leaves the agent with only the path and a one-line purpose.

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

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

Schema description coverage is 100%, so both limit and offset are already documented in the schema. The description adds nothing about these parameters, which is the expected baseline when the schema does the work.

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

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

The description names the verb and resource (GET /admin/service/order) and gives a purpose phrase ('list of services available for registration'), so the basic function is inferable. However, it offers no differentiation from the numerous sibling listing tools such as admin_service_get or user_service_order_get, and much of the text is boilerplate (tag, spec).

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternative tools. The only routing hint is the 'admin' spec label, which doesn't tell an agent when to prefer this over sibling endpoints.

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

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

No annotations are provided, so the description carries the full disclosure burden and delivers almost none of it. It implies a mutation via 'PUT' and 'register', but says nothing about the confirm:true preview/commit flow, idempotency, permissions, or side effects — all of which the agent must infer from the schema instead.

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

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

The text is short and front-loads the operation, which is good. But the literal 'PUT /admin/service/order' restates the tool name, and the 'Тег'/'Спека' lines are generator metadata that consume space without helping an agent decide or invoke.

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

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

With no annotations, no output schema, and a nested request body, the description should explain the write semantics and the confirm-gated preview behavior. It instead supplies only a path, a one-line purpose, and two metadata labels, leaving the mutation contract essentially undocumented.

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

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

Schema description coverage is 100%, so the nested body (user_id, service_id) and the confirm flag are already documented in the schema. The description adds no parameter-level meaning, so the baseline 3 applies.

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

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

The Russian phrase 'Зарегистрировать услугу клиенту' (register a service to a client) does give a specific verb+resource beyond the raw HTTP path. However, it makes no attempt to distinguish itself from closely named siblings such as user_service_order_put, admin_user_service_post, or admin_service_put, so an agent cannot confidently route between them from the description alone.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. The tag ('Услуги') and spec ('admin') are metadata labels, not usage instructions, and the description never says when an admin should register a service versus use a user-facing order endpoint.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about mutating behavior, required permissions, reversibility, or the preview/confirm flow (that detail is buried in the schema). It also leaves a semantic mismatch unexplained: POST with a stated 'modify' intent, while a separate update (PUT) sibling 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?

It is very short and free of redundancy, but the brevity comes from being auto-generated endpoint metadata rather than a front-loaded explanation. The tag/spec fragments occupy space without adding decision-relevant information.

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

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

This is a mutation tool with no annotations and no output schema, and it operates on a nested 15-field service object, so the description should at minimum explain the create-vs-update semantics and the confirm/preview behavior. Instead it offers only an endpoint path and a two-word action, which is inadequate for the complexity.

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

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

Schema description coverage is 100% and every body field carries a Russian title, so the schema already documents parameters thoroughly. The description adds nothing about the body fields or the confirm parameter; the baseline 3 applies when the schema does the heavy lifting.

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 Russian fragment 'Изменить услугу' (modify a service) gives a verb and resource, so the purpose is identifiable, but the surrounding text is raw endpoint metadata ('POST /admin/service', 'Тег: Услуги', 'Спека: admin') rather than an explanation. It does not distinguish this tool from the sibling admin_service_put, and POST semantics vs. a stated modify action is left ambiguous (create or update?).

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 no when-to-use guidance at all: it never says when to call admin_service_post versus admin_service_put, admin_service_delete, or admin_service_children_post. The only usage hint lives in the schema for the 'confirm' parameter, not in the description.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the route: no auth requirements, side effects, reversibility, or rate limits. It does imply a mutation via 'Создать услугу', but the important confirm/preview behavior only appears in the schema's confirm field, not the description.

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

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

It is short and route-front-loaded, so it is not verbose. However, the 'Тег: Услуги' and 'Спека: admin' lines are low-value metadata that do not meaningfully help an agent, and the text is too sparse for the decision at hand.

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 create endpoint with a large nested body object, no annotations, and no output schema, the description omits almost everything an agent needs: required vs optional fields, the confirm/preview semantics, and request behavior. It is essentially a bare route stub.

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

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

Schema description coverage is 100%, so the schema already documents the nested body fields and the confirm flag. The description adds no parameter meaning of its own, which matches the baseline 3 when the schema does the work.

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 verb and resource ('Создать услугу' = create a service) under a raw 'PUT /admin/service' route, so the basic purpose is inferable. However it gives no differentiation from close siblings like admin_service_post, admin_service_get, admin_service_delete, and the description is essentially an unprocessed HTTP route dump.

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 endpoint versus admin_service_post or admin_service_delete, nor prerequisites or conditions. The 'Тег'/ 'Спека' metadata lines are organizational labels, not 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?

No annotations are provided, so the description carries the full behavioral burden. It says 'delete' but not whether the deletion is irreversible, whether an in-flight spool task is cancelled, what happens to history, or what auth/permissions are required. The confirm-preview behavior lives only in the schema, not the description. For a destructive mutation with zero annotation coverage this is a significant gap.

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

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

Very short, which is efficient, but front-loaded with raw method/path plus Russian metadata lines ('Тег', 'Спека') that add no operational value. It is under-specification rather than true conciseness.

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

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

For a destructive delete tool with no annotations and no output schema, the definition leaves key questions unanswered: reversibility, permissions, effect on related spool/history data, and how it differs from the many other admin_spool_* sibling tools. Incomplete for a mutation of this blast radius.

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

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

Schema description coverage is 100%, so all three parameters (id, confirm, user_id) are already documented in the schema, including the preview-vs-execute semantics of confirm. The description adds nothing beyond the path. Baseline 3 is correct when the schema does the heavy lifting.

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

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

The description gives an HTTP method and path (DELETE /admin/spool) plus a terse Russian gloss 'Удалить задачу' (delete a task). That identifies the verb and resource, but among ~140 siblings it never distinguishes this from admin_spool_history_get, admin_spool_statuses_get, or other spool operations, nor does it say what 'задача' means in this system. Adequate but with a clear sibling-differentiation gap.

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

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

No when-to-use guidance, no prerequisites, no indication of when this delete is appropriate versus admin_spool_put or admin_spool_post. The only routing information present ('Тег: Задачи', 'Спека: admin') is metadata rather than usage advice.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses only the raw endpoint. It implies a read via GET but says nothing about authentication/authorization requirements, pagination semantics beyond defaults, or what a spool task entry represents.

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

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

The text is short and front-loads the endpoint, but the trailing "Тег: Задачи" and "Спека: admin" are generator boilerplate that add no 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 listing tool with no annotations, no output schema, and no differentiation from sibling spool endpoints, the description is too thin. It does not explain the shape of returned spool tasks or how the list relates to history/status variants.

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

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

Schema description coverage is 100%, so limit, offset, and user_id are already documented in the schema (as record count, skip offset, and user id). The description adds no additional meaning, so the baseline 3 applies.

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

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

The description states the HTTP verb and resource ("GET /admin/spool") and glosses it as "Список текущих задач" (list of current tasks), so the basic purpose is inferable. However, it offers no differentiation from close siblings such as admin_spool_history_get, admin_spool_statuses_get, or admin_user_service_spool_get, leaving the agent to guess which spool listing applies.

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

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

There is no guidance on when to use this tool versus the many sibling spool/history/status endpoints. The only context is the tag and spec metadata, which do not indicate selection conditions 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only gives the HTTP route. It does not disclose pagination defaults, whether the result is filtered to a user, ordering, or result shape. 'GET' implies read-only, but nothing about auth requirements, archive size, or rate limits 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?

It is very short, but not usefully so – three cryptic lines mixing an endpoint path, a tagline, and a 'spec' tag. There is no front-loaded purpose sentence; the content is metadata noise rather than earned brevity.

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

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

No output schema, no annotations, and only an endpoint string. For an archive/history listing endpoint in a dense admin family, the description leaves required behavioral context (pagination semantics, filtering, read-only confirmation) entirely to inference.

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

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

Schema description coverage is 100%, so the three parameters (limit, offset, user_id) are each documented in the schema itself with Russian descriptions and defaults. The description adds no parameter meaning beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description is essentially an endpoint signature ('GET /admin/spool/history') plus a terse Russian tagline ('Список архива задач' – list of task archive). It conveys the HTTP verb and resource but is a bare restatement of the route rather than a purpose statement. It does not distinguish this tool from siblings like admin_spool_get or admin_spool_statuses_get in any meaningful way.

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 indication of when to use this tool versus alternatives. Given the crowded admin_spool_* family (get, post, put, delete, manual_by_action, statuses), an agent has no guidance on selection. The 'Спека: admin' tag adds no usage direction.

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

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

No annotations are provided, so the description carries the full burden. It mentions a manual status change but does not disclose required permissions, whether the change is reversible, side effects, or the confirm/preview mechanism (which is only hinted at in the parameter schema). The description is essentially a tag line, not behavioral context.

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

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

The description is very short, but it wastes space on an endpoint URL and metadata tags ("Тег: Задачи", "Спека: admin") that do not help an agent invoke the tool. It is under-specified rather than concise; the core semantic content is barely one line.

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

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

For a mutation tool with no annotations, no output schema, and a nested body object, the description is far too thin. It does not explain what the action does, what values the action path parameter accepts, or what the confirm flag implies in terms of execution. An agent cannot confidently use this tool based on the description alone.

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

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

Schema description coverage is 100%, so the schema already documents the parameters (action path param, body id, confirm flag with preview behavior). The description adds nothing beyond what the schema provides, so baseline 3 applies.

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

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

The description is essentially a restatement of the HTTP endpoint ("POST /admin/spool/manual/{action}") plus generic tags. The phrase "Изменить статус задачи вручную" gives a faint hint of manual status change, but it is not integrated into a clear purpose statement and the `{action}` placeholder is never explained. An agent would struggle to distinguish this from sibling tools like admin_spool_post or admin_spool_statuses_get.

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 tool versus the many sibling tools. No prerequisites, no alternatives, no context. The description does not tell the agent anything about when this endpoint is appropriate.

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

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

No annotations are provided, so the description carries the full burden for a mutation endpoint, yet it discloses nothing: not whether this creates or overwrites a task, what fields are accepted, permission requirements, scheduling/priority side effects, or what the confirm preview returns. 'Изменить задачу' is too thin for a write operation on a rich body object.

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

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

It is short, but most of the text is a raw HTTP path plus tag/spec metadata ('Тег: Задачи', 'Спека: admin') that adds no task-relevant information. It is not front-loaded around what the agent needs to decide or act.

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

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

For a tool with a large nested JSON body, many readOnly fields, no output schema, and no annotations, the description is completely inadequate — an agent has no basis to distinguish it from the other spool operations or to know what the call accomplishes.

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

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

Schema description coverage is 100% and the two top-level parameters (body, confirm) are documented in the schema, including the rw-mode confirm semantics. The description adds no syntax or meaning beyond this, which is the expected baseline when the schema does the heavy lifting.

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

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

The description is essentially a restatement of the endpoint ('POST /admin/spool') plus 'Изменить задачу' (modify task). It gives a bare verb+resource but is close to tautological with the tool name and offers no differentiation from the many sibling spool tools (admin_spool_put, admin_spool_delete, admin_spool_manual_by_action_post).

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative (PUT vs POST, or use of admin_spool_manual_by_action_post). The only usage hint ('confirm:true required for non-GET in rw mode') lives in the schema, not the description.

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

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

With no annotations, the description carries the full behavioral burden but discloses almost nothing beyond 'create'. It does not mention that this is a mutation, that it upserts at a collection endpoint, or that the confirm flag gates a preview in rw mode (a detail present only in the schema). Minimal disclosure for a write 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?

Very short and effectively front-loaded, but the first line merely restates the tool name and the Tag/Spec lines are spec-bundle noise with little value for an invoking agent. Concise, yet low information density.

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

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

This is a mutation tool with a nested request body, no annotations, and no output schema, so the description needs to carry more weight. It leaves out request semantics, side effects, and required confirm behavior, providing far less than the complexity demands.

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

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

Schema description coverage is 100% – both the nested body object and the confirm flag carry their own titles/descriptions, including the rw-mode preview behavior. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Создать задачу' = create a task) beyond the raw 'PUT /admin/spool' endpoint line, so the agent knows it writes a task. However, it offers no distinction from sibling tools such as admin_spool_post or admin_spool_manual_by_action_post, and is essentially a bare OpenAPI label.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives among the numerous admin_spool_* siblings. The 'Тег: Задачи' and 'Спека: admin' lines are spec metadata, not usage direction, so the agent gets no help choosing this over admin_spool_post.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The only hint is the HTTP verb GET implying a read operation; there is no mention of authentication requirements, pagination behavior, what is returned, or rate limits.

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

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

The description is short and front-loads the endpoint path, with no padding. However, it is a bare metadata block rather than a purposeful sentence, and the path largely repeats the tool name, so it is concise but low-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 paginated read endpoint with no output schema, the description should at least say what is returned (task statuses list) and how pagination behaves. It offers no return-value or behavior context, leaving the agent underspecified for a 2-parameter 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?

Schema description coverage is 100%: both limit ('Макс. кол-во записей') and offset ('Смещение') are documented in the schema. The description adds no meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description gives a verb (GET) and resource (/admin/spool/statuses) plus a Russian gloss ('Статусы задач' = task statuses), so the basic purpose is inferable. However, it is essentially a restatement of the endpoint path and name, and it does nothing to distinguish this tool from close siblings like admin_spool_get or admin_spool_history_get.

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

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

There is no guidance on when to use this tool versus alternatives such as admin_spool_get, admin_spool_history_get, or admin_user_service_spool_get. The agent is left to infer usage entirely from the path and name.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It implies a read ('GET', 'Получить'), but says nothing about auth requirements, whether 'user_id' scopes admin access to a specific user's storage, or how pagination affects the returned object. The HTTP fragment gives minimal behavioral context without any of the details needed for safe invocation.

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

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

The content is short but poorly structured: a raw route, a Russian noun phrase, and two separate tag/spec lines ('Тег: Хранилище', 'Спека: admin'). These fragments are metadata leaks from the source spec rather than front-loaded, task-oriented information, so brevity does not translate into clarity.

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

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

For an admin mutation-adjacent tool with no annotations and no output schema, the description should convey the effect of parameters, auth expectations, and return behavior. It provides none of these, leaving an agent to guess from the name and schema alone; the raw HTTP path hints at the operation but is not sufficient for correct use.

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

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

Schema coverage is 100% and all four parameters (name, limit, offset, user_id) carry descriptions in the schema, so the schema already does the explanatory work. The description adds no syntax, format, or semantic detail beyond the schema, which establishes the baseline of 3.

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

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

The description is essentially a raw OpenAPI fragment: an HTTP verb/path and a one-line Russian gloss ('Получить объект хранилища' = 'Get a storage object'). It conveys the verb and resource at a surface level, but it is largely a tautological restatement of the function name admin_storage_manage_by_name_get, and it never distinguishes this admin tool from the many sibling storage tools (admin_storage_manage_get, user_storage_manage_by_name_get).

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

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

There is no guidance on when to use this tool versus the extensive set of sibling storage tools, nor any prerequisites such as admin authorization. The only signal is implied by the 'admin' prefix in the name; the description adds nothing about context of use.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that this is a DELETE and that it removes an object, but says nothing about permissions, irreversibility, or side effects. The one concrete behavior (the confirm/rw preview mode) lives in the schema, not the description.

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

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

The description is short and front-loads the HTTP endpoint, but 'Тег: Хранилище' and 'Спека: admin' are low-value metadata lines that do not help an agent invoke the tool. It is terse rather than truly economical.

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

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

For a destructive delete with no annotations and no output schema, the description is too thin: it omits permission requirements, irreversibility, and any confirmation workflow context (left entirely to the schema). Given the lack of annotations, the description should have carried more of the behavioral load.

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

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

Schema description coverage is 100%, so the schema already documents user_id, name, and the confirm-preview behavior. The description adds no parameter-level detail beyond what the schema provides, which is the correct baseline of 3 when the schema does the heavy lifting.

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

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

The description gives a specific verb and resource: 'DELETE /admin/storage/manage' paired with 'Удалить объект из хранилища' (delete an object from storage). This is clear and unambiguous, but it does nothing to distinguish itself from the many closely-named siblings like admin_storage_manage_get/post/put or user_storage_manage_delete.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives (e.g. how it relates to user_storage_manage_delete or admin_storage_manage_by_name_delete). The 'Tag/Spec' lines are routing metadata, not 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?

With no annotations provided, the description carries the full burden, yet it only implies a read via 'GET'. It does not disclose that limit/offset are paginated defaults (25/0), whether an admin role is required, or what the response contains. The spec/tag lines add no behavioral context.

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

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

The text is short, but a large share of it (the raw path, 'Тег: Хранилище', 'Спека: admin') is generator boilerplate that adds no agent value. The one useful sentence is buried under it rather than 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 read-only list with no output schema, the description still should say this is the admin-wide listing, note pagination behavior, and distinguish it from the by_name and user-scoped siblings. None of that is present, so an agent lacks what it needs to choose this tool confidently.

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

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

Schema description coverage is 100% ('Макс. кол-во записей', 'Смещение', 'id пользователя'), so the schema already documents all three parameters. The description adds no filtering semantics beyond the schema, which is the expected baseline when coverage is high.

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 Russian line 'Получить список объектов хранилища' does state a verb+resource (get a list of storage objects), so the purpose is discernible. However, it does not distinguish this admin-scoped listing from the many siblings (admin_storage_manage_by_name_get, user_storage_manage_get), and the REST path/tag/spec preamble is machine-generated noise rather than clarification.

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

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

There is no statement of when to use this listing versus admin_storage_manage_by_name_get or the user_* variants, and no mention of required permissions or pagination expectations. Usage must be inferred entirely from the name and HTTP verb.

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

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

No annotations are provided, so the description carries full behavioral burden, yet it only says data in a storage object is changed. It does not disclose permissions/auth requirements, the preview-vs-execute effect of the confirm flag, what happens to unmentioned fields, or the fact that this is a mutation. For a generic admin write endpoint, this is a significant gap.

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

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

It is short, but the content is raw scaffolding (HTTP path, tag, spec) rather than thoughtful description text, so brevity comes at the cost of usefulness rather than from trimming wasted words. The only real purpose statement is a single fragment.

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 an admin mutation with a nested object body, no annotations, and no output schema, the description is thin. It omits the confirm/preview mechanism, field semantics, and any indication of what a successful change entails, leaving too much for the agent to infer.

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

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

Schema description coverage is 100% and there are only 2 top-level parameters (body, confirm), so the schema documents them adequately and the baseline of 3 applies. The description adds no extra meaning about the body fields (data, name, user_id, settings, etc.) or the confirm semantics beyond what the schema already states.

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

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

The description gives a verb and resource ("Изменить данные в объекте хранилища" = change data in a storage object) and labels it admin-scoped, which is reasonably clear. However, it is wrapped in raw HTTP/boilerplate metadata ("POST /admin/storage/manage", "Тег: Хранилище", "Спека: admin") and gives no way to distinguish it from the many sibling mutations such as admin_storage_manage_put, admin_storage_manage_delete, or the by_name variants. Purpose is stated but minimally.

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

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

There is no guidance on when to use this tool versus the numerous alternatives (put, delete, get, by_name, user_storage_manage_*). No prerequisites, no context, no exclusions are given. The agent must infer usage entirely from the name.

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

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

No annotations are present, so the description carries the full burden. It says 'PUT' which implies mutation, but nothing about permissions, reversibility, or the read-only 'created' field behavior. The only behavioral hint is buried in the schema's 'confirm' parameter description, not the tool description itself.

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 cluttered with raw HTTP method/path and internal metadata (tag, spec) rather than being front-loaded with useful natural-language purpose. The one useful clause is buried, and the rest is routing noise.

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 mutating admin storage endpoint with no annotations, no output schema, and a nested body object, the description is far too thin. It doesn't explain the confirm/preview flow, what the endpoint returns, or how it relates to the many sibling storage operations.

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

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

Schema coverage is reported at 100% and the schema does describe the nested body fields (data, name, created, user_id, settings, user_service_id) and the confirm flag. The description adds nothing beyond the schema, so baseline 3 applies.

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

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

The Russian line 'Создать объект в хранилище' (create an object in storage) is a specific verb+resource, but it is buried under a raw HTTP method/path and Russian tag/spec metadata ('Тег: Хранилище', 'Спека: admin'). It doesn't meaningfully distinguish itself from the many sibling storage tools (user_storage_manage_put, admin_storage_manage_post, admin_storage_manage_by_name_...), and the routing noise dominates.

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

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

No when-to-use, when-not-to-use, or alternative-tool guidance is given. With dozens of sibling storage endpoints, an agent has no way to know why it should pick this one over admin_storage_manage_post or admin_storage_manage_by_name_put.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the HTTP verb. It says nothing about admin authorization requirements, rate limits, or that the limit/offset parameters imply the response may be paged rather than a single template.

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

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

It is short and front-loads the method and path, but three of the four lines are boilerplate metadata (tag, spec, path) rather than information an agent needs to invoke the tool, so the brevity reflects low content rather than efficient curation.

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

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

With no annotations and no output schema, the description should carry more weight, but for a tool with three parameters (including pagination params that conflict with a single-id read) it omits the return shape, admin scope, and sibling differentiation.

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

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

Schema description coverage is 100%, so the schema already documents id, limit, and offset; the description adds no syntax or format detail. Baseline 3 applies, though the schema's 'имя шаблона' (name) label for a path id is slightly inconsistent with the '{id}' placeholder.

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 pairs a read verb ('Прочитать шаблон' / GET) with the resource (admin template by id), so the basic operation is discernible. However it does not distinguish this from close siblings such as admin_template_get or user_template_by_id_get, and the non-English text plus raw path leaves the exact scope 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?

There is no statement of when to use this tool versus alternatives like admin_template_get or user_template_by_id_get. The 'Тег: Шаблоны' / 'Спека: admin' lines are metadata, not 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?

No annotations are provided, so the description carries the full behavioral burden for a destructive DELETE operation. It states nothing about irreversibility, required permissions, or what happens to associated data, leaving the critical safety context to the schema's confirm field.

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

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

The description is short and front-loads the endpoint, but the "Тег" and "Спека" lines are metadata that adds no actionable value for an agent. It is terse without being informative.

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

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

For a destructive delete tool with no annotations and no output schema, the description is too thin: it omits behavior on success/failure, permission requirements, and the relationship to the confirm parameter. The confirm semantics live only in the schema, leaving the description incomplete for the operation's safety profile.

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

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

Schema description coverage is 100%, so the schema already documents both the required id and the confirm parameter (including the preview-without-confirm behavior). The description adds no additional parameter meaning, which matches the baseline 3 when the schema does the heavy lifting.

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 ("DELETE /admin/template" / "Удалить шаблон"), so the basic action is identifiable. However, it is largely a raw endpoint dump and offers no scope clarification (e.g., whether deletion is by id) nor any differentiation from siblings like admin_template_get/post/put.

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

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

No when-to-use guidance, prerequisites, or alternatives are provided. Nothing tells the agent when to prefer this over admin_template_put or the by-id siblings. Usage must be inferred entirely from the tool name.

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

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

No annotations are provided, so the description carries the full disclosure burden. It never states that this is a read-only, non-destructive operation, nor describes pagination defaults or return shape. The route implies GET semantics but the description does not make safety or behavior explicit.

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

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

The text is short but is a raw dump of route, tag, and spec metadata rather than a front-loaded natural-language description. The most useful information (that it lists templates with pagination) is buried behind the HTTP route string, and the 'Тег'/'Спека' fields add structure without descriptive 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 list endpoint with two pagination parameters, no output schema, and no annotations, the description should at least state the read-only nature and pagination behavior. It provides route and tag metadata but omits behavioral and usage context an agent needs to call it correctly.

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

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

Schema coverage is 100%: the schema already documents limit (max records) and offset (skip records) with defaults and minimums. The description adds nothing beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states the HTTP method and route (GET /admin/template) and tags it as 'Список шаблонов' (list of templates), so the resource and read nature are inferable. However, it never spells out in prose that this returns a paginated list of templates, relying instead on the route string. It is adequate but minimally explicit compared to siblings like admin_template_by_id_get.

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

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

There is no guidance on when to use this versus admin_template_by_id_get or the POST/PUT/DELETE variants. The only signal is the verb implied by the route. An agent must infer that a bare GET /admin/template means 'list all' rather than retrieve one.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about mutation effects, required permissions, or reversibility. The only behavioral safety net (the confirm/preview mechanism) lives in the schema, not the description, so the agent gets no reinforcement here.

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

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

The text is short and front-loaded, but the trailing 'Тег' and 'Спека' lines are low-value metadata rather than information an agent needs to invoke the tool, so not every token 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?

This is a mutating POST with a nested body object, no output schema, and no annotations, so the description should explain the write semantics and the confirm-preview workflow. Instead it offers only the HTTP path and 'change template', which is inadequate for a tool of this complexity.

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

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

Schema description coverage is 100% — the body fields (id, data, settings) and the confirm flag are already documented in the schema. The description adds no parameter meaning beyond the raw endpoint path, so the baseline 3 applies.

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

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

The description states a verb+resource ('POST /admin/template — Изменить шаблон' = change template), so the basic purpose is identifiable. However, it does not distinguish this POST from the sibling admin_template_put or admin_template_delete, all of which appear to mutate the same template resource, leaving the agent unable to 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?

There is no when-to-use guidance, no condition selecting this over admin_template_put/delete, and no mention of prerequisites. The 'Tag: Шаблоны / Spec: admin' trailer is organizational metadata, not usage direction.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the HTTP verb. It does not state idempotency/replace semantics inherent to PUT, permission requirements, what happens on overwrite of an existing template, or the confirm-gated preview behavior (that detail lives only in the schema).

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

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

The text is brief but that brevity reflects under-specification rather than tight writing: it is a raw route plus a tag/spec header with no actionable content front-loaded. Nearly every line is filler for an agent deciding how to call 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?

This is a mutating admin tool with no annotations, no output schema, and a nested request body, yet the description supplies no mutation semantics, permissions, or return expectations. It is not sufficient for an agent to invoke it confidently without falling back entirely on the schema.

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

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

Schema description coverage is 100%, and the schema itself explains both parameters, including the important 'confirm' preview behavior and the nested body fields (id, data, settings). The description adds nothing on top, so the baseline of 3 for high schema coverage applies.

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

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

The description does state a verb and resource ('Создать шаблон' / create template) alongside the raw HTTP route 'PUT /admin/template', so an agent can tell it creates a template. However, it offers no differentiation from the closely named sibling admin_template_post, which also appears to write templates, so the agent cannot confidently choose between them.

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

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

There is no when-to-use guidance, no prerequisite information, and no pointer to alternatives such as admin_template_post or admin_template_get. The 'Тег' and 'Спека' strings are taxonomy metadata, not usage instructions.

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

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

No annotations are provided, so the description carries the full burden. It reveals nothing about permissions required, whether deletion is hard or soft, reversibility, or side effects on the user balance. The only concrete hint is buried in a parameter description ('без confirm:true в режиме rw возвращается превью'), not the tool description itself.

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?

Terse, but the content is a bare HTTP method/path echo plus tag and spec metadata lines ('Тег: Бонусы', 'Спека: admin'). Those metadata lines are low-value for an agent choosing a tool, so the brevity is under-information rather than efficiency.

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 destructive mutation tool with no annotations and no output schema should explain consequences, permissions, and confirmation flow in the description. Instead it leaves the confirm/preview behavior to a single schema field and says nothing about what deleting the bonus actually affects, leaving an agent under-equipped to call this safely.

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

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

Schema description coverage is 100%, so the schema already documents id, user_id, and the confirm-preview mechanism. The description adds no parameter semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description restates the HTTP method and path (DELETE /admin/user/bonus) plus a one-line Russian restatement 'Удалить бонус'. This is functional but read directly off the tool name and is largely tautological. It is distinguishable from admin_user_bonus_get/post/put only by the HTTP verb embedded in the name itself, not by any value-add in the description.

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

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

No when-to-use, when-not-to-use, prerequisites, or alternative-tool guidance. There is no mention of when a bonus should be deleted versus edited (admin_user_bonus_put) or how this differs from other admin user delete operations like admin_user_pay_delete.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no admin authorization requirement, no pagination/limit semantics beyond the schema, no indication of what is returned or whether results are filtered. The raw GET path weakly implies a safe read, but that is inference rather than disclosure.

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

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

It is short, but much of the length is auto-generated filler ("Тег: Бонусы", "Спека: admin") rather than front-loaded substance. The useful part is a single gloss line, so it is neither bloated nor well-structured.

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

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

For a zero-annotation tool with no output schema and an admin-scoped endpoint, the description omits the authorization requirement, pagination behavior, and result shape. The schema covers inputs, but nothing compensates for the missing behavioral 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 100% (limit, offset, user_id all documented in the schema), so the baseline of 3 applies. The description adds no additional meaning about defaults, filtering behavior, or what user_id scoping does when omitted.

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

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

The description states the HTTP verb and path plus a one-line gloss ("Список бонусов клиентов" = list of client bonuses), so the resource and read-only listing intent are inferable. However, it does no work to distinguish this from the many sibling admin_user_bonus_* tools beyond the bare name, and relies on the reader to translate a raw spec dump into a 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?

There is no statement of when to use this tool versus admin_user_bonus_post/put/delete or admin_user_get. The only context is the noise-style tag ("Бонусы") and spec name ("admin"), which hint at scope but give no selection criteria.

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

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

No annotations are provided, so the description carries full behavioral burden. The schema itself reveals a confirm flag and preview-mode semantics for non-GET operations, and the description adds zero context on permission requirements, reversibility, or what changes. The raw endpoint path is not behavioral disclosure.

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 content is short but mis-structured: a raw route and a tag/spec metadata tuple ('Тег: Бонусы', 'Спека: admin') that are OpenAPI-doc artifacts, not agent-facing guidance. It is under-specified rather than concise.

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

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

This is a mutation endpoint with a nested body object and a confirm-token workflow, none of which the description addresses. With no annotations, no output schema, and no usage guidance, the definition leaves an agent without enough to call it correctly or safely.

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

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

Schema coverage is 100% and parameter titles are descriptive (bonus id, user_id, bonus count, date, comment), so the schema does the heavy lifting. The description contributes nothing about the confirm/preview mechanic, but baseline 3 is warranted when schema coverage is complete.

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

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

The description is essentially a raw HTTP route ('POST /admin/user/bonus') plus a Russian tagline ('Изменить бонус' = 'Change bonus'). While 'Изменить бонус' does convey a mutate-bonus intent, the definition is dominated by an endpoint path that tells the agent nothing about business purpose, and it doesn't distinguish the tool from sibling admin_user_bonus_get/put/delete.

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

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

No when-to-use, prerequisites, or alternative guidance. Critically, the description never routes the agent away from the sibling admin_user_bonus_put (which the name suggests should be the update tool) despite this tool being a POST-based bonus change. Nothing helps the agent choose.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only labels the tool as a create/PUT. It says nothing about authorization requirements, whether it is idempotent, what happens on repeated calls, or how the created bonus interacts with existing ones. For a write operation with zero annotation coverage this is a significant gap.

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

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

It is short and front-loads the HTTP path and purpose, but two of the four lines ("Тег: Бонусы", "Спека: admin") are low-value metadata that consume space without helping selection or invocation. Terse, but the brevity reflects under-specification rather than tight editing.

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

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

This is a mutation tool with no annotations, no output schema, and a nested request body, so the description should carry more context. Instead it offers only HTTP verb, a one-line purpose, and tag/spec labels, leaving permissions, side effects, and return behavior entirely undocumented.

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

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

Schema description coverage is 100%, so the schema already documents body fields (id, date, bonus, comment, user_id) and the confirm flag in detail. The description adds no parameter meaning beyond that, so the baseline of 3 applies.

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

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

The description does convey a verb+resource ("Создать бонус" = create a bonus) alongside the HTTP path PUT /admin/user/bonus, so the agent knows the operation. However, it gives no way to distinguish this from the sibling admin_user_bonus_post, which presumably also creates a bonus, and the PUT vs POST create ambiguity is left entirely unresolved. Purpose is identifiable but not differentiated from siblings.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as admin_user_bonus_post or admin_user_bonus_get. The agent must infer usage purely from the name and HTTP verb, with no explicit routing information.

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

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

No annotations are provided, so the description must carry the full behavioral burden, but it only restates the name and HTTP route. For a destructive deletion tool, it says nothing about irreversibility, cascade effects (e.g., deleting user services or payments), required permissions, or rate limits. The confirm parameter's preview behavior is documented in the schema, not the description.

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

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

The description is very short but mostly consists of metadata (method, path, tags, spec reference) rather than explanatory prose. It is not front-loaded with meaningful purpose and wastes its limited length on restating the name and route.

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

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

For a destructive admin deletion tool with no annotations and no output schema, the description is completely inadequate. It fails to communicate risks, preconditions, or expected outcomes, leaving the agent unprepared to invoke it safely.

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

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

Schema coverage is 100%, so the input schema already fully documents both parameters (user_id and confirm). The description adds no parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description is essentially a raw HTTP method and path (DELETE /admin/user) plus a Russian phrase 'Удалить клиента' (delete client) that restates the tool name. It does not explain scope, side effects, or differentiate from siblings like admin_user_put or admin_user_post beyond the HTTP verb. An agent must infer purpose entirely from the name.

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

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

There is no guidance on when to use this tool versus alternatives such as admin_user_put or admin_user_post, nor any prerequisites or exclusions. The only usage hint is the implicit DELETE semantics from the path, which is not a deliberate guideline.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no auth/permission requirements for an admin endpoint, no note on whether results are paginated or bounded, and no indication of what a response contains. It is an empty API stub.

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

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

It is short and front-loads the method and path, which is good, but the remaining lines ('Тег', 'Спека') are generator noise that consumes space without adding meaning.

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

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

With no annotations and no output schema, the description should explain return shape (is it a list, what fields, how pagination interacts with limit/offset) and any admin authorization requirement. None of that is present, leaving an agent unable to predict the call's behavior.

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

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

Schema description coverage is 100%, so limit, offset, and user_id are already documented (in Russian), establishing a baseline of 3. The description adds nothing beyond that, and notably does not clarify why a 'user_id' filter exists on a list endpoint.

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 pairs the HTTP verb+path (GET /admin/user) with 'Список клиентов' (list of clients), which conveys a list operation over user records. However, it never reconciles 'clients' with the 'user' resource, and it does nothing to distinguish this from the many sibling list/search endpoints such as admin_user_search_get or user_get.

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

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

There is no guidance on when to use this tool versus admin_user_search_get, user_get, or any other of the ~130 siblings. The only context is the auto-generated 'Тег: Пользователи' and 'Спека: admin' metadata, which is not actionable 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the route: no admin authorization requirement, no statement that the old password is overwritten irreversibly, no mention of the read-write preview behavior. The 'confirm' preview mechanic is only explained inside the schema, not the description.

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

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

It is short and front-loaded with the HTTP route, but it reads as a raw endpoint dump: 'Тег: Пользователи' and 'Спека: admin' are catalog metadata that give the agent little to act on, and the terse Russian line leaves no room for the details an invoker needs.

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

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

For a privileged password-mutation tool with no annotations and no output schema, the definition is too thin: it omits the admin authorization requirement, reversibility, the encrypted-password expectation, and the confirm/preview gate. An agent cannot call this correctly on the description alone.

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